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 <stdio.h>
  36 #include <string.h>
  37
  38 #ifdef HAVE_UNISTD_H
  39 #include <unistd.h>
  40 #endif
  41
  42 #include <gtk/gtk.h>
  43 #include <gdk/gdkkeysyms.h>
  44 #if GTK_CHECK_VERSION(3,0,0)
  45 # include <gdk/gdkkeysyms-compat.h>
  46 #endif
  47
  48 #include <epan/epan_dissect.h>
  49 #include <epan/tap.h>
  50 #include <epan/dissectors/packet-rtp.h>
  51 #include <epan/addr_resolv.h>
  52 #include "epan/filesystem.h"
  53
  54 #include "../util.h"
  55 #include "../simple_dialog.h"
  56 #include "../alert_box.h"
  57 #include <wsutil/file_util.h>
  58
  59 #include "gtk/gtkglobals.h"
  60 #include "gtk/file_dlg.h"
  61 #include "gtk/gui_utils.h"
  62 #include "gtk/dlg_utils.h"
  63 #include "gtk/main.h"
  64 #include "gtk/graph_analysis.h"
  65
  66 #include "gtk/old-gtk-compat.h"
  67
  68 #include "../image/voip_bg.xpm"
  69
  70 /****************************************************************************/
  71
  72
  73 #define OK_TEXT "[ Ok ]"
  74 #define PT_UNDEFINED -1
  75
  76
  77 static GtkWidget *save_to_file_w = NULL;
  78
  79 #define MAX_LABEL 50
  80 #define MAX_COMMENT 100
  81 #define ITEM_HEIGHT 20
  82 #define NODE_WIDTH 100
  83 #define TOP_Y_BORDER 40
  84 #define BOTTOM_Y_BORDER 2
  85 #define COMMENT_WIDTH 400
  86 #define TIME_WIDTH 50
  87
  88 #define NODE_CHARS_WIDTH 20
  89 #define CONV_TIME_HEADER       "Conv.| Time    "
  90 #define TIME_HEADER "|Time     "
  91 #define CONV_TIME_EMPTY_HEADER "     |         "
  92 #define TIME_EMPTY_HEADER      "|         "
  93 #define CONV_TIME_HEADER_LENGTH 16
  94 #define TIME_HEADER_LENGTH 10
  95
  96 /****************************************************************************/
  97 /* Reset the user_data structure */
  98 static void graph_analysis_reset(graph_analysis_data_t *user_data)
  99 {
 100         int i;
 101
 102         user_data->num_nodes = 0;
 103         user_data->num_items = 0;
 104         for (i=0; i<MAX_NUM_NODES; i++){
 105                 user_data->nodes[i].type = AT_NONE;
 106                 user_data->nodes[i].len = 0;
 107                 g_free((void *)user_data->nodes[i].data);
 108                 user_data->nodes[i].data = NULL;
 109         }
 110
 111         user_data->dlg.first_node=0;
 112         user_data->dlg.first_item=0;
 113         user_data->dlg.left_x_border=0;
 114         user_data->dlg.selected_item=0xFFFFFFFF;    /*not item selected */
 115 }
 116
 117 /****************************************************************************/
 118 /* Init the user_data structure */
 119 static void graph_analysis_init_dlg(graph_analysis_data_t *user_data)
 120 {
 121         int i;
 122         user_data->num_nodes = 0;
 123         user_data->num_items = 0;
 124         user_data->on_destroy_user_data = NULL;
 125         user_data->data = NULL;
 126         for (i=0; i<MAX_NUM_NODES; i++){
 127                 user_data->nodes[i].type = AT_NONE;
 128                 user_data->nodes[i].len = 0;
 129                 user_data->nodes[i].data = NULL;
 130         }
 131
 132         user_data->dlg.first_node=0;
 133         user_data->dlg.first_item=0;
 134         user_data->dlg.left_x_border=0;
 135         user_data->dlg.selected_item=0xFFFFFFFF;    /*not item selected */
 136         /* init dialog_graph */
 137         user_data->dlg.needs_redraw=TRUE;
 138         user_data->dlg.draw_area_time=NULL;
 139         user_data->dlg.draw_area=NULL;
 140         user_data->dlg.draw_area_comments=NULL;
 141 #if GTK_CHECK_VERSION(2,22,0)
 142         user_data->dlg.surface_main=NULL;
 143         user_data->dlg.surface_time=NULL;
 144         user_data->dlg.surface_comments=NULL;
 145 #else
 146         user_data->dlg.pixmap_main=NULL;
 147         user_data->dlg.pixmap_time=NULL;
 148         user_data->dlg.pixmap_comments=NULL;
 149 #endif
 150         user_data->dlg.v_scrollbar=NULL;
 151         user_data->dlg.v_scrollbar_adjustment=NULL;
 152         user_data->dlg.hpane=NULL;
 153         user_data->dlg.surface_width = 350;
 154         user_data->dlg.surface_width=400;
 155         user_data->dlg.first_node=0;
 156         user_data->dlg.first_item=0;
 157         user_data->dlg.left_x_border=0;
 158         user_data->dlg.selected_item=0xFFFFFFFF;    /*not item selected */
 159         user_data->dlg.window=NULL;
 160         user_data->dlg.parent_w=NULL;
 161         user_data->dlg.inverse = FALSE;
 162         user_data->dlg.title=NULL;
 163 }
 164
 165 /****************************************************************************/
 166 /* CALLBACKS */
 167
 168 /****************************************************************************/
 169 /* close the dialog window */
 170 static void on_destroy(GtkWidget *win _U_, graph_analysis_data_t *user_data)
 171 {
 172         int i;
 173
 174         for (i=0; i<MAX_NUM_NODES; i++){
 175                 user_data->nodes[i].type = AT_NONE;
 176                 user_data->nodes[i].len = 0;
 177                 g_free((void *)user_data->nodes[i].data);
 178                 user_data->nodes[i].data = NULL;
 179         }
 180         user_data->dlg.window = NULL;
 181         g_free(user_data->dlg.title);
 182         user_data->dlg.title = NULL;
 183
 184         if(user_data->on_destroy_user_data){
 185                 user_data->on_destroy_user_data(user_data->data);
 186         }
 187 }
 188
 189 #define RIGHT_ARROW 1
 190 #define LEFT_ARROW 0
 191 #define WIDTH_ARROW 8
 192 #define HEIGHT_ARROW 6
 193
 194 /****************************************************************************/
 195 #if GTK_CHECK_VERSION(2,22,0)
 196 static void draw_arrow(cairo_surface_t *surface, GdkColor *color, gint x, gint y, gboolean arrow_type)
 197 {
 198         cairo_t *cr;
 199
 200         cr = cairo_create (surface);
 201         gdk_cairo_set_source_color (cr, color);
 202         if (arrow_type == LEFT_ARROW)
 203         {
 204                 cairo_move_to (cr, x + WIDTH_ARROW,      y);
 205                 cairo_line_to (cr, x + WIDTH_ARROW,      y + HEIGHT_ARROW);
 206                 cairo_line_to (cr, x,                    y + HEIGHT_ARROW / 2.);
 207         }
 208         else if (arrow_type == RIGHT_ARROW)
 209         {
 210                 cairo_move_to (cr, x,                    y);
 211                 cairo_line_to (cr, x + WIDTH_ARROW,      y + HEIGHT_ARROW / 2.);
 212                 cairo_line_to (cr, x,                    y + HEIGHT_ARROW);
 213         }
 214         cairo_close_path (cr);
 215         cairo_fill (cr);
 216
 217         cairo_destroy (cr);
 218 }
 219 #else
 220 static void draw_arrow(GdkDrawable *pixmap, GdkColor *color, gint x, gint y, gboolean arrow_type)
 221 {
 222         cairo_t *cr;
 223
 224         if (GDK_IS_DRAWABLE(pixmap)) {
 225                 cr = gdk_cairo_create (pixmap);
 226                 gdk_cairo_set_source_color (cr, color);
 227                 if (arrow_type == LEFT_ARROW)
 228                 {
 229                         cairo_move_to (cr, x + WIDTH_ARROW,      y);
 230                         cairo_line_to (cr, x + WIDTH_ARROW,      y + HEIGHT_ARROW);
 231                         cairo_line_to (cr, x,                    y + HEIGHT_ARROW / 2.);
 232                 }
 233                 else if (arrow_type == RIGHT_ARROW)
 234                 {
 235                         cairo_move_to (cr, x,                    y);
 236                         cairo_line_to (cr, x + WIDTH_ARROW,      y + HEIGHT_ARROW / 2.);
 237                         cairo_line_to (cr, x,                    y + HEIGHT_ARROW);
 238                 }
 239                 cairo_close_path (cr);
 240                 cairo_fill (cr);
 241
 242                 cairo_destroy (cr);
 243         }
 244 }
 245 #endif
 246
 247 /****************************************************************************/
 248 /* Adds trailing characters to complete the requested length.               */
 249 /****************************************************************************/
 250
 251 static void enlarge_string(GString *gstr, guint32 length, char pad){
 252
 253         gsize i;
 254
 255         for (i = gstr->len; i < length; i++){
 256                 g_string_append_c(gstr, pad);
 257         }
 258 }
 259
 260 /****************************************************************************/
 261 /* overwrites the characters in a string, between positions p1 and p2, with */
 262 /*   the characters of text_to_insert                                       */
 263 /*   NB: it does not check that p1 and p2 fit into string                   */
 264 /****************************************************************************/
 265
 266 static void overwrite (GString *gstr, char *text_to_insert, guint32 p1, guint32 p2){
 267
 268         gsize len;
 269         gsize pos;
 270
 271         if (p1 == p2)
 272                 return;
 273
 274         if (p1 > p2){
 275                 pos = p2;
 276                 len = p1 - p2;
 277         }
 278         else{
 279                 pos = p1;
 280                 len = p2 - p1;
 281         }
 282
 283         if (len > strlen(text_to_insert)){
 284                 len = strlen(text_to_insert);
 285         }
 286
 287         if (pos > gstr->len)
 288                 pos = gstr->len;
 289
 290         /* ouch this is ugly but gtk1 needs it */
 291         if ((pos + len) > gstr->len)
 292                 g_string_truncate(gstr, pos);
 293         else
 294                 g_string_erase(gstr, pos, len);
 295
 296         g_string_insert(gstr, pos, text_to_insert);
 297 }
 298
 299 /****************************************************************************/
 300 static gboolean dialog_graph_dump_to_file(graph_analysis_data_t *user_data)
 301 {
 302         guint32 i, first_node, display_items, display_nodes;
 303         guint32 start_position, end_position, item_width, header_length;
 304         graph_analysis_item_t *gai;
 305         guint16  first_conv_num = 0;
 306         gboolean several_convs = FALSE;
 307         gboolean first_packet  = TRUE;
 308
 309         GString *label_string, *empty_line,*separator_line, *tmp_str, *tmp_str2;
 310         char    *empty_header;
 311         char     src_port[8],dst_port[8];
 312
 313         GList *list;
 314
 315         FILE  *of;
 316
 317         of = ws_fopen(user_data->dlg.save_file,"w");
 318         if (of==NULL){
 319                 open_failure_alert_box(user_data->dlg.save_file, errno, TRUE);
 320                 return FALSE;
 321         }
 322
 323         label_string   = g_string_new("");
 324         empty_line     = g_string_new("");
 325         separator_line = g_string_new("");
 326         tmp_str        = g_string_new("");
 327         tmp_str2       = g_string_new("");
 328
 329         display_items = 0;
 330         list = g_list_first(user_data->graph_info->list);
 331         while (list)
 332         {
 333                 gai = list->data;
 334                 list = g_list_next(list);
 335
 336                 if (!gai->display)
 337                         continue;
 338
 339                 display_items += 1;
 340                 if (first_packet){
 341                         first_conv_num = gai->conv_num;
 342                         first_packet=FALSE;
 343                 }
 344                 else if (gai->conv_num != first_conv_num){
 345                         several_convs = TRUE;
 346                 }
 347         }
 348
 349         /* if not items to display */
 350         if (display_items == 0)
 351                 goto exit;
 352
 353         display_nodes = user_data->num_nodes;
 354
 355         first_node = user_data->dlg.first_node;
 356
 357         /* Write the conv. and time headers */
 358         if (several_convs){
 359                 fprintf(of, CONV_TIME_HEADER);
 360                 empty_header = CONV_TIME_EMPTY_HEADER;
 361                 header_length = CONV_TIME_HEADER_LENGTH;
 362         }
 363         else{
 364                 fprintf(of, TIME_HEADER);
 365                 empty_header = TIME_EMPTY_HEADER;
 366                 header_length = TIME_HEADER_LENGTH;
 367         }
 368
 369         /* Write the node names on top */
 370         for (i=0; i<display_nodes; i+=2){
 371                 /* print the node identifiers */
 372                 g_string_printf(label_string, "| %s",
 373                         get_addr_name(&(user_data->nodes[i+first_node])));
 374                 enlarge_string(label_string, NODE_CHARS_WIDTH*2, ' ');
 375                 fprintf(of, "%s", label_string->str);
 376                 g_string_printf(label_string, "| ");
 377                 enlarge_string(label_string, NODE_CHARS_WIDTH, ' ');
 378                 g_string_append(empty_line, label_string->str);
 379         }
 380
 381         fprintf(of, "|\n%s", empty_header);
 382         g_string_printf(label_string, "| ");
 383         enlarge_string(label_string, NODE_CHARS_WIDTH, ' ');
 384         fprintf(of, "%s", label_string->str);
 385
 386         /* Write the node names on top */
 387         for (i=1; i<display_nodes; i+=2){
 388                 /* print the node identifiers */
 389                 g_string_printf(label_string, "| %s",
 390                         get_addr_name(&(user_data->nodes[i+first_node])));
 391                 if (label_string->len < NODE_CHARS_WIDTH)
 392                 {
 393                         enlarge_string(label_string, NODE_CHARS_WIDTH, ' ');
 394                         g_string_append(label_string, "| ");
 395                 }
 396                 enlarge_string(label_string, NODE_CHARS_WIDTH*2, ' ');
 397                 fprintf(of, "%s", label_string->str);
 398                 g_string_printf(label_string, "| ");
 399                 enlarge_string(label_string, NODE_CHARS_WIDTH, ' ');
 400                 g_string_append(empty_line, label_string->str);
 401         }
 402
 403         fprintf(of, "\n");
 404
 405         g_string_append_c(empty_line, '|');
 406
 407         enlarge_string(separator_line, (guint32) empty_line->len + header_length, '-');
 408
 409         /*
 410          * Draw the items
 411          */
 412
 413         list = g_list_first(user_data->graph_info->list);
 414         while (list)
 415         {
 416                 gai = list->data;
 417                 list = g_list_next(list);
 418
 419                 if (!gai->display)
 420                         continue;
 421
 422                 start_position = (gai->src_node-first_node)*NODE_CHARS_WIDTH+NODE_CHARS_WIDTH/2;
 423
 424                 end_position = (gai->dst_node-first_node)*NODE_CHARS_WIDTH+NODE_CHARS_WIDTH/2;
 425
 426                 if (start_position > end_position){
 427                         item_width=start_position-end_position;
 428                 }
 429                 else if (start_position < end_position){
 430                         item_width=end_position-start_position;
 431                 }
 432                 else{ /* same origin and destination address */
 433                         end_position = start_position+NODE_CHARS_WIDTH;
 434                         item_width = NODE_CHARS_WIDTH;
 435                 }
 436
 437                 /* separator between conversations */
 438                 if (gai->conv_num != first_conv_num){
 439                         fprintf(of, "%s\n", separator_line->str);
 440                         first_conv_num=gai->conv_num;
 441                 }
 442
 443                 /* write the conversation number */
 444                 if (several_convs){
 445                         g_string_printf(label_string, "%i", gai->conv_num);
 446                         enlarge_string(label_string, 5, ' ');
 447                         fprintf(of, "%s", label_string->str);
 448                 }
 449
 450                 /* write the time */
 451                 g_string_printf(label_string, "|%.3f", gai->time);
 452                 enlarge_string(label_string, 10, ' ');
 453                 fprintf(of, "%s", label_string->str);
 454
 455                 /* write the frame label */
 456
 457                 g_string_printf(tmp_str, "%s", empty_line->str);
 458                 overwrite(tmp_str,gai->frame_label,
 459                         start_position,
 460                         end_position
 461                         );
 462                 fprintf(of, "%s", tmp_str->str);
 463
 464                 /* write the comments */
 465                 fprintf(of, "%s\n", gai->comment);
 466
 467                 /* write the arrow and frame label*/
 468                 fprintf(of, "%s", empty_header);
 469
 470                 g_string_printf(tmp_str, "%s", empty_line->str);
 471
 472                 g_string_truncate(tmp_str2, 0);
 473
 474                 if (start_position<end_position){
 475                         enlarge_string(tmp_str2, item_width-2, '-');
 476                         g_string_append_c(tmp_str2, '>');
 477                 }
 478                 else{
 479                         g_string_printf(tmp_str2, "<");
 480                         enlarge_string(tmp_str2, item_width-1, '-');
 481                 }
 482
 483                 overwrite(tmp_str,tmp_str2->str,
 484                         start_position,
 485                         end_position
 486                         );
 487
 488                 g_snprintf(src_port,sizeof(src_port),"(%i)", gai->port_src);
 489                 g_snprintf(dst_port,sizeof(dst_port),"(%i)", gai->port_dst);
 490
 491                 if (start_position<end_position){
 492                         overwrite(tmp_str,src_port,start_position-9,start_position-1);
 493                         overwrite(tmp_str,dst_port,end_position+1,end_position+9);
 494                 }
 495                 else{
 496                         overwrite(tmp_str,src_port,start_position+1,start_position+9);
 497                         overwrite(tmp_str,dst_port,end_position-9,end_position+1);
 498                 }
 499
 500                 fprintf(of,"%s\n",tmp_str->str);
 501         }
 502
 503 exit:
 504         g_string_free(label_string, TRUE);
 505         g_string_free(empty_line, TRUE);
 506         g_string_free(separator_line, TRUE);
 507         g_string_free(tmp_str, TRUE);
 508         g_string_free(tmp_str2, TRUE);
 509
 510         fclose (of);
 511         return TRUE;
 512
 513 }
 514
 515 /****************************************************************************/
 516 static void save_to_file_destroy_cb(GtkWidget *win _U_, gpointer user_data _U_)
 517 {
 518         /* Note that we no longer have a Save to file dialog box. */
 519         save_to_file_w = NULL;
 520 }
 521
 522 /****************************************************************************/
 523 /* save in a file */
 524
 525 /* first an auxiliary function in case we need an overwrite confirmation dialog */
 526
 527 static void overwrite_existing_file_cb(gpointer dialog _U_, gint btn, gpointer user_data)
 528 {
 529         switch(btn) {
 530         case(ESD_BTN_YES):
 531             /* overwrite the file*/
 532             dialog_graph_dump_to_file(user_data);
 533             break;
 534         case(ESD_BTN_NO):
 535             break;
 536         default:
 537             g_assert_not_reached();
 538         }
 539 }
 540
 541 /* and then the save in a file dialog itself */
 542
 543 static gboolean save_to_file_ok_cb(GtkWidget *ok_bt _U_, gpointer user_data)
 544 {
 545         FILE *file_test;
 546         graph_analysis_data_t *user_data_p = user_data;
 547
 548         user_data_p->dlg.save_file = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(save_to_file_w));
 549
 550         /* Perhaps the user specified a directory instead of a file.
 551            Check whether they did. */
 552         if (test_for_directory(user_data_p->dlg.save_file) == EISDIR) {
 553                 /* It's a directory - set the file selection box to display it. */
 554                 set_last_open_dir(user_data_p->dlg.save_file);
 555                 file_selection_set_current_folder(save_to_file_w, get_last_open_dir());
 556                 gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(save_to_file_w), "");
 557                 g_free(user_data_p->dlg.save_file);
 558                 return FALSE;  /* run the dialog again */
 559         }
 560
 561         /* GtkFileChooserDialog/gtk_dialog_run is currently being used.         */
 562         /*      So: Trying to leave the graph_analysis window up if graph_dump  */
 563         /*          fails doesn't work well.                                    */
 564         /*  (See comment under on_save_bt_clicked)                              */
 565         /*                                                                      */
 566         /* As a work-around:                                                    */
 567         /*  We'll always destroy the window.                                    */
 568
 569         /* check whether the file exists */
 570         file_test = ws_fopen(user_data_p->dlg.save_file,"r");
 571         if (file_test!=NULL){
 572                 gpointer dialog;
 573                 dialog = simple_dialog(ESD_TYPE_CONFIRMATION, ESD_BTNS_YES_NO,
 574                   "%sFile: \"%s\" already exists!%s\n\n"
 575                   "Do you want to overwrite it?",
 576                   simple_dialog_primary_start(),user_data_p->dlg.save_file, simple_dialog_primary_end());
 577                 simple_dialog_set_cb(dialog, overwrite_existing_file_cb, user_data);
 578                 fclose(file_test);
 579                 return TRUE;
 580         }
 581
 582         else{
 583                 if (!dialog_graph_dump_to_file(user_data)) {
 584                         /* Couldn't open the file ?  */
 585                         g_free(user_data_p->dlg.save_file);
 586                         return TRUE;
 587                 }
 588         }
 589         g_free(user_data_p->dlg.save_file);
 590         return TRUE;
 591 }
 592
 593 /****************************************************************************/
 594 static void
 595 on_save_bt_clicked                    (GtkWidget       *button _U_,
 596                                        graph_analysis_data_t *user_data)
 597 {
 598 #if 0  /* XXX: GtkFileChooserDialog/gtk_dialog_run currently being used is effectively modal so this is not req'd */
 599         if (save_to_file_w != NULL) {
 600                 /* There's already a Save to file dialog box; reactivate it. */
 601                 reactivate_window(save_to_file_w);
 602                 return;
 603         }
 604 #endif
 605         save_to_file_w =
 606                 gtk_file_chooser_dialog_new("Wireshark: Save graph to plain text file",
 607                                             GTK_WINDOW(user_data->dlg.window),
 608                                             GTK_FILE_CHOOSER_ACTION_SAVE,
 609                                             GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
 610                                             GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
 611                                             NULL);
 612
 613         g_signal_connect(save_to_file_w, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
 614         g_signal_connect(save_to_file_w, "destroy", G_CALLBACK(save_to_file_destroy_cb), NULL);
 615
 616         gtk_widget_show(save_to_file_w);
 617         window_present(save_to_file_w);
 618
 619         /* "Run" the GtkFileChooserDialog.                                              */
 620         /* Upon exit: If "Accept" run the OK callback.                                  */
 621         /*            If the OK callback returns with a FALSE status, re-run the dialog.*/
 622         /*            Destroy the window.                                               */
 623         /* XXX: If the OK callback pops up an alert box (eg: for an error) it *must*    */
 624         /*      return with a TRUE status so that the dialog window will be destroyed.  */
 625         /*      Trying to re-run the dialog after popping up an alert box will not work */
 626         /*       since the user will not be able to dismiss the alert box.              */
 627         /*      The (somewhat unfriendly) effect: the user must re-invoke the           */
 628         /*      GtkFileChooserDialog whenever the OK callback pops up an alert box.     */
 629         /*                                                                              */
 630         /*      ToDo: use GtkFileChooserWidget in a dialog window instead of            */
 631         /*            GtkFileChooserDialog.                                             */
 632         while (gtk_dialog_run(GTK_DIALOG(save_to_file_w)) == GTK_RESPONSE_ACCEPT) {
 633                 if (save_to_file_ok_cb(NULL, user_data)) {
 634                         break;  /* we're done */
 635                 }
 636         }
 637         window_destroy(save_to_file_w);
 638 }
 639
 640 /****************************************************************************/
 641 static void dialog_graph_draw(graph_analysis_data_t *user_data)
 642 {
 643         guint32 i, last_item, first_item, display_items;
 644         guint32 start_arrow, end_arrow, label_x, src_port_x, dst_port_x, arrow_width;
 645         guint32 current_item;
 646         guint32 left_x_border;
 647         guint32 right_x_border;
 648         guint32 top_y_border;
 649         guint32 bottom_y_border;
 650         graph_analysis_item_t *gai;
 651
 652         PangoLayout  *layout;
 653         PangoLayout  *middle_layout;
 654         PangoLayout  *small_layout;
 655         PangoFontDescription *middle_font_desc;
 656         gint middle_font_size;
 657         PangoFontDescription *small_font_desc;
 658         gint small_font_size;
 659
 660         gint label_width, label_height;
 661         guint32 draw_width, draw_height;
 662         char label_string[MAX_COMMENT];
 663         GList *list;
 664         cairo_t *cr;
 665
 666
 667         GdkColor *color_p, *bg_color_p;
 668         GdkColor black_color = {0, 0, 0, 0};
 669         GdkColor white_color = {0, 0xffff, 0xffff, 0xffff};
 670         /* gray and soft gray colors */
 671         GdkColor grey_color0 = {0, 0x64ff, 0x64ff, 0x64ff};
 672         GdkColor grey_color1 = {0, 0x25ff, 0x25ff, 0x25ff};
 673
 674         /* the first color is blue to highlight the selected item */
 675         static GdkColor background_color[MAX_NUM_COL_CONV+1] = {
 676                 {0,     0x00FF, 0x00FF, 0xFFFF},
 677                 {0,     0x90FF, 0xEEFF, 0x90FF},
 678                 {0,     0xFFFF, 0xA0FF, 0x7AFF},
 679                 {0,     0xFFFF, 0xB6FF, 0xC1FF},
 680                 {0,     0xFAFF, 0xFAFF, 0xD2FF},
 681                 {0,     0xFFFF, 0xFFFF, 0x33FF},
 682                 {0,     0x66FF, 0xCDFF, 0xAAFF},
 683                 {0,     0xE0FF, 0xFFFF, 0xFFFF},
 684                 {0,     0xB0FF, 0xC4FF, 0xDEFF},
 685                 {0,     0x87FF, 0xCEFF, 0xFAFF},
 686                 {0,     0xD3FF, 0xD3FF, 0xD3FF}
 687         };
 688
 689         /* XXX can't we just set the background color ? */
 690         GdkPixbuf *bg_pixbuf =  gdk_pixbuf_new_from_xpm_data(voip_bg_xpm);
 691
 692         /* Dashed line pattern */
 693         static const double dashed1[] = {5.0, 4.0};
 694         static int len1  = sizeof(dashed1) / sizeof(dashed1[0]);
 695
 696         GtkAllocation draw_area_time_alloc, draw_area_alloc, draw_area_comments_alloc;
 697
 698         if(!user_data->dlg.needs_redraw){
 699                 return;
 700         }
 701         user_data->dlg.needs_redraw=FALSE;
 702
 703         gtk_widget_get_allocation(user_data->dlg.draw_area_time, &draw_area_time_alloc);
 704         gtk_widget_get_allocation(user_data->dlg.draw_area, &draw_area_alloc);
 705         gtk_widget_get_allocation(user_data->dlg.draw_area_comments, &draw_area_comments_alloc);
 706
 707         /* Clear out old plot */
 708 #if GTK_CHECK_VERSION(2,22,0)
 709         cr = cairo_create (user_data->dlg.surface_time);
 710         cairo_set_source_rgb (cr, 1, 1, 1);
 711         cairo_rectangle (cr, 0, 0, draw_area_time_alloc.width,draw_area_time_alloc.height);
 712         cairo_fill (cr);
 713         cairo_destroy (cr);
 714
 715         cr = cairo_create (user_data->dlg.surface_main);
 716         cairo_set_source_rgb (cr, 1, 1, 1);
 717         cairo_rectangle (cr, 0, 0, draw_area_alloc.width,draw_area_alloc.height);
 718         cairo_fill (cr);
 719         cairo_destroy (cr);
 720
 721         cr = cairo_create (user_data->dlg.surface_comments);
 722         cairo_set_source_rgb (cr, 1, 1, 1);
 723         cairo_rectangle (cr, 0, 0, draw_area_comments_alloc.width,draw_area_comments_alloc.height);
 724         cairo_fill (cr);
 725         cairo_destroy (cr);
 726
 727 #else
 728         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_time) ){
 729                 cr = gdk_cairo_create (user_data->dlg.pixmap_time);
 730                 cairo_set_source_rgb (cr, 1, 1, 1);
 731                 cairo_rectangle (cr, 0, 0, draw_area_time_alloc.width,draw_area_time_alloc.height);
 732                 cairo_fill (cr);
 733                 cairo_destroy (cr);
 734         }
 735
 736         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_main) ){
 737                 cr = gdk_cairo_create (user_data->dlg.pixmap_main);
 738                 cairo_set_source_rgb (cr, 1, 1, 1);
 739                 cairo_rectangle (cr, 0, 0, draw_area_alloc.width,draw_area_alloc.height);
 740                 cairo_fill (cr);
 741                 cairo_destroy (cr);
 742         }
 743
 744         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments) ){
 745                 cr = gdk_cairo_create (user_data->dlg.pixmap_comments);
 746                 cairo_set_source_rgb (cr, 1, 1, 1);
 747                 cairo_rectangle (cr, 0, 0, draw_area_comments_alloc.width,draw_area_comments_alloc.height);
 748                 cairo_fill (cr);
 749                 cairo_destroy (cr);
 750         }
 751 #endif
 752         /* Calculate the y border */
 753         top_y_border=TOP_Y_BORDER;      /* to display the node address */
 754         bottom_y_border=BOTTOM_Y_BORDER;
 755
 756         draw_height=draw_area_alloc.height-top_y_border-bottom_y_border;
 757
 758         first_item = user_data->dlg.first_item;
 759         display_items = draw_height/ITEM_HEIGHT;
 760
 761         /* get the items to display and fill the matrix array */
 762         list = g_list_first(user_data->graph_info->list);
 763         current_item = 0;
 764         i = 0;
 765         while (list)
 766         {
 767                 gai = list->data;
 768                 if (gai->display){
 769                         if (current_item>=display_items) break;         /* the item is outside the display */
 770                         if (i>=first_item){
 771                                 user_data->dlg.items[current_item].frame_num = gai->frame_num;
 772                                 user_data->dlg.items[current_item].time = gai->time;
 773                                 user_data->dlg.items[current_item].port_src = gai->port_src;
 774                                 user_data->dlg.items[current_item].port_dst = gai->port_dst;
 775                                 /* Add "..." if the length is 50 characters */
 776                                 if (strlen(gai->frame_label) > 48) {
 777                                         gai->frame_label[48] = '.';
 778                                         gai->frame_label[47] = '.';
 779                                         gai->frame_label[46] = '.';
 780                                 }
 781                                 user_data->dlg.items[current_item].frame_label = gai->frame_label;
 782                                 user_data->dlg.items[current_item].comment = gai->comment;
 783                                 user_data->dlg.items[current_item].conv_num = gai->conv_num;
 784
 785                                 user_data->dlg.items[current_item].src_node = gai->src_node;
 786                                 user_data->dlg.items[current_item].dst_node = gai->dst_node;
 787                                 user_data->dlg.items[current_item].line_style = gai->line_style;
 788                                 current_item++;
 789                         }
 790                         i++;
 791                 }
 792
 793                 list = g_list_next(list);
 794         }
 795         /* in case the window is resized we might have to move the top item */
 796         if ((first_item + display_items) > user_data->num_items){
 797                 if (display_items>user_data->num_items)
 798                         first_item=0;
 799                 else
 800                         first_item = user_data->num_items - display_items;
 801         }
 802
 803         /* in case there are less items than possible displayed */
 804         display_items = current_item;
 805         last_item = first_item+display_items-1;
 806
 807         /* if no items to display */
 808         if (display_items == 0) return;
 809
 810
 811         /* Calculate the x borders */
 812         /* We use time from the last display item to calcultate the x left border */
 813         g_snprintf(label_string, MAX_LABEL, "%.3f", user_data->dlg.items[display_items-1].time);
 814         layout = gtk_widget_create_pango_layout(user_data->dlg.draw_area_time, label_string);
 815         middle_layout = gtk_widget_create_pango_layout(user_data->dlg.draw_area_time, label_string);
 816         small_layout = gtk_widget_create_pango_layout(user_data->dlg.draw_area_time, label_string);
 817
 818         middle_font_desc = pango_font_description_copy(pango_context_get_font_description(pango_layout_get_context(middle_layout)));
 819         middle_font_size = pango_font_description_get_size(middle_font_desc);
 820         pango_font_description_set_size(middle_font_desc,(gint)(middle_font_size*0.8));
 821         pango_layout_set_font_description(middle_layout,middle_font_desc);
 822
 823         small_font_desc = pango_font_description_copy(pango_context_get_font_description(pango_layout_get_context(small_layout)));
 824         small_font_size = pango_font_description_get_size(small_font_desc);
 825         pango_font_description_set_size(small_font_desc,(gint)(small_font_size*0.7));
 826         pango_layout_set_font_description(small_layout,small_font_desc);
 827
 828         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 829
 830         /* resize the "time" draw area */
 831         left_x_border=0;
 832         user_data->dlg.left_x_border = left_x_border;
 833
 834         right_x_border=0;
 835         draw_width=user_data->dlg.surface_width-right_x_border-left_x_border;
 836
 837 #if GTK_CHECK_VERSION(2,22,0)
 838         /* Paint time title background */
 839         cr = cairo_create (user_data->dlg.surface_time);
 840         gdk_cairo_set_source_pixbuf (cr, bg_pixbuf, 0, 0);
 841         cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
 842         cairo_rectangle (cr, 0, 0, draw_area_time_alloc.width, top_y_border);
 843         cairo_fill (cr);
 844         cairo_destroy (cr);
 845
 846         /* Paint main title background */
 847         cr = cairo_create (user_data->dlg.surface_main);
 848         gdk_cairo_set_source_pixbuf (cr, bg_pixbuf, 0, 0);
 849         cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
 850         cairo_rectangle (cr, 0, 0, draw_area_alloc.width, top_y_border);
 851         cairo_fill (cr);
 852         cairo_destroy (cr);
 853
 854         /* Paint main comment background */
 855         cr = cairo_create (user_data->dlg.surface_comments);
 856         gdk_cairo_set_source_pixbuf (cr, bg_pixbuf, 0, 0);
 857         cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
 858         cairo_rectangle (cr, 0, 0, draw_area_comments_alloc.width, top_y_border);
 859         cairo_fill (cr);
 860         cairo_destroy (cr);
 861 #else
 862         /* Paint time title background */
 863         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_time) ){
 864                 cr = gdk_cairo_create (user_data->dlg.pixmap_time);
 865                 gdk_cairo_set_source_pixbuf (cr, bg_pixbuf, 0, 0);
 866                 cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
 867                 cairo_rectangle (cr, 0, 0, draw_area_time_alloc.width, top_y_border);
 868                 cairo_fill (cr);
 869                 cairo_destroy (cr);
 870
 871         }
 872         /* Paint main title background */
 873         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_main) ){
 874                 cr = gdk_cairo_create (user_data->dlg.pixmap_main);
 875                 gdk_cairo_set_source_pixbuf (cr, bg_pixbuf, 0, 0);
 876                 cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
 877                 cairo_rectangle (cr, 0, 0, draw_area_alloc.width, top_y_border);
 878                 cairo_fill (cr);
 879                 cairo_destroy (cr);
 880         }
 881
 882         /* Paint main comment background */
 883         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments) ){
 884                 cr = gdk_cairo_create (user_data->dlg.pixmap_comments);
 885                 gdk_cairo_set_source_pixbuf (cr, bg_pixbuf, 0, 0);
 886                 cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
 887                 cairo_rectangle (cr, 0, 0, draw_area_comments_alloc.width, top_y_border);
 888                 cairo_fill (cr);
 889                 cairo_destroy (cr);
 890         }
 891
 892 #endif
 893         /* Draw the word "Time" on top of time column */
 894         g_snprintf(label_string, label_width, "%s", "  Time");
 895         pango_layout_set_text(layout, label_string, -1);
 896         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 897 #if GTK_CHECK_VERSION(2,22,0)
 898         cr = cairo_create (user_data->dlg.surface_time);
 899         cairo_move_to (cr, left_x_border, top_y_border/2-label_height/2);
 900         pango_cairo_show_layout (cr, layout);
 901         cairo_destroy (cr);
 902         cr = NULL;
 903 #else
 904         if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_time)) {
 905                 cr = gdk_cairo_create (user_data->dlg.pixmap_time);
 906                 cairo_move_to (cr, left_x_border, top_y_border/2-label_height/2);
 907                 pango_cairo_show_layout (cr, layout);
 908                 cairo_destroy (cr);
 909                 cr = NULL;
 910         }
 911 #endif
 912         /* Draw the word "Comment" on top of comment column */
 913         g_snprintf(label_string, label_width, "%s", "Comment");
 914         pango_layout_set_text(layout, label_string, -1);
 915         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 916 #if GTK_CHECK_VERSION(2,22,0)
 917         cr = cairo_create (user_data->dlg.surface_comments);
 918         cairo_move_to (cr, MAX_COMMENT/2-label_width/2, top_y_border/2-((i&1)?0:label_height));
 919         pango_cairo_show_layout (cr, layout);
 920         cairo_destroy (cr);
 921         cr = NULL;
 922 #endif
 923         /* Paint the background items */
 924         for (current_item=0; current_item<display_items; current_item++){
 925                 /*select the color. if it is the selected item select blue color */
 926                 if ( current_item+first_item == user_data->dlg.selected_item ) {
 927                         bg_color_p = &background_color[0]; /* blue */
 928                 } else {
 929                         bg_color_p = &background_color[1+user_data->dlg.items[current_item].conv_num%MAX_NUM_COL_CONV];
 930                 }
 931 #if GTK_CHECK_VERSION(2,22,0)
 932                 /* Paint background */
 933                 cr = cairo_create (user_data->dlg.surface_main);
 934                 gdk_cairo_set_source_color (cr, bg_color_p);
 935                 cairo_rectangle (cr, left_x_border, top_y_border+current_item*ITEM_HEIGHT, draw_width, ITEM_HEIGHT);
 936                 cairo_fill (cr);
 937                 cairo_destroy (cr);
 938 #else
 939                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_main)) {
 940                         /* Paint background */
 941                         cr = gdk_cairo_create (user_data->dlg.pixmap_main);
 942                         gdk_cairo_set_source_color (cr, bg_color_p);
 943                         cairo_rectangle (cr, left_x_border, top_y_border+current_item*ITEM_HEIGHT, draw_width, ITEM_HEIGHT);
 944                         cairo_fill (cr);
 945                         cairo_destroy (cr);
 946                 }
 947 #endif
 948         }
 949         /* Draw the node names on top and the division lines */
 950         for (i=0; i<user_data->num_nodes; i++){
 951                 /* print the node identifiers */
 952                 /* XXX we assign 5 pixels per character in the node identity */
 953                 g_strlcpy(label_string, get_addr_name(&(user_data->nodes[i])), NODE_WIDTH/5);
 954                 pango_layout_set_text(layout, label_string, -1);
 955                 pango_layout_get_pixel_size(layout, &label_width, &label_height);
 956 #if GTK_CHECK_VERSION(2,22,0)
 957                 cr = cairo_create (user_data->dlg.surface_main);
 958                 cairo_move_to (cr, left_x_border+NODE_WIDTH/2-label_width/2+NODE_WIDTH*i, top_y_border/2-((i&1)?0:label_height));
 959                 pango_cairo_show_layout (cr, layout);
 960                 cairo_destroy (cr);
 961                 cr = NULL;
 962 #else
 963                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_main)) {
 964                         cr = gdk_cairo_create (user_data->dlg.pixmap_main);
 965                         cairo_move_to (cr, left_x_border+NODE_WIDTH/2-label_width/2+NODE_WIDTH*i, top_y_border/2-((i&1)?0:label_height));
 966                         pango_cairo_show_layout (cr, layout);
 967                         cairo_destroy (cr);
 968                         cr = NULL;
 969                 }
 970 #endif
 971 #if GTK_CHECK_VERSION(2,22,0)
 972                 /* draw the node division lines */
 973                 cr = cairo_create (user_data->dlg.surface_main);
 974                 gdk_cairo_set_source_color (cr, &grey_color0);
 975                 cairo_set_line_width (cr, 1.0);
 976                 cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
 977                 cairo_set_dash(cr, dashed1, len1, 0);
 978                 cairo_move_to(cr, left_x_border+NODE_WIDTH/2+NODE_WIDTH*i, top_y_border);
 979                 cairo_line_to(cr, (left_x_border+NODE_WIDTH/2+NODE_WIDTH*i),draw_area_alloc.height-bottom_y_border);
 980                 cairo_stroke(cr);
 981                 cairo_destroy(cr);
 982 #else
 983                 /* draw the node division lines */
 984                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_main) ) {
 985                         cr = gdk_cairo_create (user_data->dlg.pixmap_main);
 986                         gdk_cairo_set_source_color (cr, &grey_color0);
 987                         cairo_set_line_width (cr, 1.0);
 988                         cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
 989                         cairo_set_dash(cr, dashed1, len1, 0);
 990                         cairo_move_to(cr, left_x_border+NODE_WIDTH/2+NODE_WIDTH*i, top_y_border);
 991                         cairo_line_to(cr, (left_x_border+NODE_WIDTH/2+NODE_WIDTH*i),draw_area_alloc.height-bottom_y_border);
 992                         cairo_stroke(cr);
 993                         cairo_destroy(cr);
 994                 }
 995 #endif
 996         }
 997
 998         /* Draw the items */
 999         for (current_item=0; current_item<display_items; current_item++){
1000                 /* draw the time */
1001                 g_snprintf(label_string, MAX_LABEL, "%.3f", user_data->dlg.items[current_item].time);
1002                 pango_layout_set_text(layout, label_string, -1);
1003                 pango_layout_get_pixel_size(layout, &label_width, &label_height);
1004 #if GTK_CHECK_VERSION(2,22,0)
1005                 cr = cairo_create (user_data->dlg.surface_time);
1006                 cairo_move_to (cr, 3, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2);
1007                 pango_cairo_show_layout (cr, layout);
1008                 cairo_destroy (cr);
1009                 cr = NULL;
1010                 /*draw the comments */
1011                 g_snprintf(label_string, MAX_COMMENT, "%s", user_data->dlg.items[current_item].comment);
1012                 pango_layout_set_text(middle_layout, label_string, -1);
1013                 pango_layout_get_pixel_size(middle_layout, &label_width, &label_height);
1014                 cr = cairo_create (user_data->dlg.surface_comments);
1015                 cairo_move_to (cr, 2, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2);
1016                 pango_cairo_show_layout (cr, middle_layout);
1017                 cairo_destroy (cr);
1018                 cr = NULL;
1019 #else
1020                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_time)) {
1021                         cr = gdk_cairo_create (user_data->dlg.pixmap_time);
1022                         cairo_move_to (cr, 3, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2);
1023                         pango_cairo_show_layout (cr, layout);
1024                         cairo_destroy (cr);
1025                         cr = NULL;
1026                 }
1027                 /*draw the comments */
1028                 g_snprintf(label_string, MAX_COMMENT, "%s", user_data->dlg.items[current_item].comment);
1029                 pango_layout_set_text(middle_layout, label_string, -1);
1030                 pango_layout_get_pixel_size(middle_layout, &label_width, &label_height);
1031 #endif
1032 #if GTK_CHECK_VERSION(2,22,0)
1033                 cr = cairo_create (user_data->dlg.surface_comments);
1034                 cairo_move_to (cr, 2, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2);
1035                 pango_cairo_show_layout (cr, middle_layout);
1036                 cairo_destroy (cr);
1037                 cr = NULL;
1038 #else
1039                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_comments)) {
1040                         cr = gdk_cairo_create (user_data->dlg.pixmap_comments);
1041                         cairo_move_to (cr, 2, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2);
1042                         pango_cairo_show_layout (cr, middle_layout);
1043                         cairo_destroy (cr);
1044                         cr = NULL;
1045                 }
1046 #endif
1047                 /* draw the arrow line */
1048                 start_arrow = left_x_border+(user_data->dlg.items[current_item].src_node)*NODE_WIDTH+NODE_WIDTH/2;
1049                 end_arrow = left_x_border+(user_data->dlg.items[current_item].dst_node)*NODE_WIDTH+NODE_WIDTH/2;
1050
1051 #if GTK_CHECK_VERSION(2,22,0)
1052                 cr = cairo_create (user_data->dlg.surface_main);
1053                 if (user_data->dlg.items[current_item].line_style == 2) {
1054                         /* draw a line thick */
1055                         cairo_set_line_width (cr, 2.0);
1056                 }else{
1057                         cairo_set_line_width (cr, 1.0);
1058                 }
1059                 if ( current_item+first_item == user_data->dlg.selected_item ){
1060                         /* draw white line */
1061                         cairo_set_source_rgb (cr, 1, 1, 1);
1062                 }else{
1063                         /* draw black line */
1064                         cairo_set_source_rgb (cr, 0, 0, 0);
1065                 }
1066                 cairo_move_to(cr, start_arrow, (top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7)+0.5);
1067                 cairo_line_to(cr, end_arrow, (top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7)+0.5);
1068                 cairo_stroke(cr);
1069                 cairo_destroy(cr);
1070 #else
1071                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_main) ) {
1072                         cr = gdk_cairo_create (user_data->dlg.pixmap_main);
1073                         if (user_data->dlg.items[current_item].line_style == 2) {
1074                                 /* draw a line thick */
1075                                 cairo_set_line_width (cr, 2.0);
1076                         }else{
1077                                 cairo_set_line_width (cr, 1.0);
1078                         }
1079                         if ( current_item+first_item == user_data->dlg.selected_item ){
1080                                 /* draw white line */
1081                                 cairo_set_source_rgb (cr, 1, 1, 1);
1082                         }else{
1083                                 /* draw black line */
1084                                 cairo_set_source_rgb (cr, 0, 0, 0);
1085                         }
1086                         cairo_move_to(cr, start_arrow, (top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7)+0.5);
1087                         cairo_line_to(cr, end_arrow, (top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7)+0.5);
1088                         cairo_stroke(cr);
1089                         cairo_destroy(cr);
1090                 }
1091 #endif
1092                 /* select colors */
1093                 if ( current_item+first_item == user_data->dlg.selected_item ){
1094                         color_p = &white_color;
1095                 } else {
1096                         color_p = &black_color;
1097                 }
1098                 /* draw the arrow */
1099 #if GTK_CHECK_VERSION(2,22,0)
1100                 if (start_arrow<end_arrow)
1101                         draw_arrow(user_data->dlg.surface_main, color_p, end_arrow-WIDTH_ARROW, (top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7)-(HEIGHT_ARROW/2), RIGHT_ARROW);
1102                 else
1103                         draw_arrow(user_data->dlg.surface_main, color_p, end_arrow, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7-(HEIGHT_ARROW/2), LEFT_ARROW);
1104 #else
1105                 if (start_arrow<end_arrow)
1106                         draw_arrow(user_data->dlg.pixmap_main, color_p, end_arrow-WIDTH_ARROW, (top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7)-(HEIGHT_ARROW/2), RIGHT_ARROW);
1107                 else
1108                         draw_arrow(user_data->dlg.pixmap_main, color_p, end_arrow, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-7-(HEIGHT_ARROW/2), LEFT_ARROW);
1109 #endif
1110                 /* draw the frame comment */
1111                 g_snprintf(label_string, MAX_LABEL, "%s", user_data->dlg.items[current_item].frame_label);
1112                 pango_layout_set_text(layout, label_string, -1);
1113                 pango_layout_get_pixel_size(layout, &label_width, &label_height);
1114                 if (start_arrow<end_arrow){
1115                         arrow_width = end_arrow-start_arrow;
1116                         label_x = arrow_width/2+start_arrow;
1117                 }
1118                 else {
1119                         arrow_width = start_arrow-end_arrow;
1120                         label_x = arrow_width/2+end_arrow;
1121                 }
1122
1123                 if (label_width>(gint)arrow_width) arrow_width = label_width;
1124
1125                 if ((int)left_x_border > ((int)label_x-(int)label_width/2))
1126                         label_x = left_x_border + label_width/2;
1127
1128 #if GTK_CHECK_VERSION(2,22,0)
1129                 cr = cairo_create (user_data->dlg.surface_main);
1130                 gdk_cairo_set_source_color (cr, color_p);
1131                 cairo_move_to (cr, label_x - label_width/2, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2-3);
1132                 pango_cairo_show_layout (cr, layout);
1133                 cairo_destroy (cr);
1134                 cr = NULL;
1135 #else
1136                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_main)) {
1137                         cr = gdk_cairo_create (user_data->dlg.pixmap_main);
1138                         gdk_cairo_set_source_color (cr, color_p);
1139                         cairo_move_to (cr, label_x - label_width/2, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT/2-label_height/2-3);
1140                         pango_cairo_show_layout (cr, layout);
1141                         cairo_destroy (cr);
1142                         cr = NULL;
1143                 }
1144 #endif
1145                 /* draw the source port number */
1146                 g_snprintf(label_string, MAX_LABEL, "(%i)", user_data->dlg.items[current_item].port_src);
1147                 pango_layout_set_text(small_layout, label_string, -1);
1148                 pango_layout_get_pixel_size(small_layout, &label_width, &label_height);
1149                 if (start_arrow<end_arrow){
1150                         src_port_x = start_arrow - label_width - 2;
1151                 }
1152                 else {
1153                         src_port_x = start_arrow + 2;
1154                 }
1155 #if GTK_CHECK_VERSION(2,22,0)
1156                 cr = cairo_create (user_data->dlg.surface_main);
1157                 /* select color */
1158                 if ( current_item+first_item == user_data->dlg.selected_item ){
1159                         gdk_cairo_set_source_color (cr, &grey_color1);
1160                 } else {
1161                         gdk_cairo_set_source_color (cr, &grey_color0);
1162                 }
1163                 gdk_cairo_set_source_color (cr, &grey_color0);
1164                 cairo_move_to (cr, src_port_x, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-2-label_height/2-2);
1165                 pango_cairo_show_layout (cr, small_layout);
1166                 cairo_destroy (cr);
1167 #else
1168                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_main)) {
1169                         cr = gdk_cairo_create (user_data->dlg.pixmap_main);
1170                         /* select color */
1171                         if ( current_item+first_item == user_data->dlg.selected_item ){
1172                                 gdk_cairo_set_source_color (cr, &grey_color1);
1173                         } else {
1174                                 gdk_cairo_set_source_color (cr, &grey_color0);
1175                         }
1176                         gdk_cairo_set_source_color (cr, &grey_color0);
1177                         cairo_move_to (cr, src_port_x, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-2-label_height/2-2);
1178                         pango_cairo_show_layout (cr, small_layout);
1179                         cairo_destroy (cr);
1180                 }
1181 #endif
1182                 /* draw the destination port number */
1183                 g_snprintf(label_string, MAX_LABEL, "(%i)", user_data->dlg.items[current_item].port_dst);
1184                 pango_layout_set_text(small_layout, label_string, -1);
1185                 pango_layout_get_pixel_size(small_layout, &label_width, &label_height);
1186                 if (start_arrow<end_arrow){
1187                         dst_port_x = end_arrow + 2;
1188                 }
1189                 else {
1190                         dst_port_x = end_arrow - label_width - 2;
1191                 }
1192 #if GTK_CHECK_VERSION(2,22,0)
1193                 cr = cairo_create (user_data->dlg.surface_main);
1194                 /* select color */
1195                 if ( current_item+first_item == user_data->dlg.selected_item ){
1196                         gdk_cairo_set_source_color (cr, &grey_color1);
1197                 } else {
1198                         gdk_cairo_set_source_color (cr, &grey_color0);
1199                 }
1200                 cairo_move_to (cr, dst_port_x, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-2-label_height/2-2);
1201                 pango_cairo_show_layout (cr, small_layout);
1202                 cairo_destroy (cr);
1203 #else
1204                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_main)) {
1205                         cr = gdk_cairo_create (user_data->dlg.pixmap_main);
1206                         /* select color */
1207                         if ( current_item+first_item == user_data->dlg.selected_item ){
1208                                 gdk_cairo_set_source_color (cr, &grey_color1);
1209                         } else {
1210                                 gdk_cairo_set_source_color (cr, &grey_color0);
1211                         }
1212                         cairo_move_to (cr, dst_port_x, top_y_border+current_item*ITEM_HEIGHT+ITEM_HEIGHT-2-label_height/2-2);
1213                         pango_cairo_show_layout (cr, small_layout);
1214                         cairo_destroy (cr);
1215                 }
1216 #endif
1217                 /* draw the div line of the selected item with soft gray*/
1218                 if ( current_item+first_item == user_data->dlg.selected_item )
1219                         for (i=0; i<user_data->num_nodes; i++){
1220 #if GTK_CHECK_VERSION(2,22,0)
1221                                 cr = cairo_create (user_data->dlg.surface_main);
1222                                 gdk_cairo_set_source_color (cr, &grey_color1);
1223                                 cairo_set_line_width (cr, 1.0);
1224                                 cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
1225                                 cairo_set_dash(cr, dashed1, len1, 0);
1226                                 cairo_move_to(cr, left_x_border+NODE_WIDTH/2+NODE_WIDTH*i, (user_data->dlg.selected_item-first_item)*ITEM_HEIGHT+TOP_Y_BORDER);
1227                                 cairo_line_to(cr, (left_x_border+NODE_WIDTH/2+NODE_WIDTH*i),(user_data->dlg.selected_item-first_item)*ITEM_HEIGHT+TOP_Y_BORDER+ITEM_HEIGHT);
1228                                 cairo_stroke(cr);
1229                                 cairo_destroy(cr);
1230 #else
1231                                 if (GDK_IS_DRAWABLE(user_data->dlg.pixmap_main) ) {
1232                                         cr = gdk_cairo_create (user_data->dlg.pixmap_main);
1233                                         gdk_cairo_set_source_color (cr, &grey_color1);
1234                                         cairo_set_line_width (cr, 1.0);
1235                                         cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
1236                                         cairo_set_dash(cr, dashed1, len1, 0);
1237                                         cairo_move_to(cr, left_x_border+NODE_WIDTH/2+NODE_WIDTH*i, (user_data->dlg.selected_item-first_item)*ITEM_HEIGHT+TOP_Y_BORDER);
1238                                         cairo_line_to(cr, (left_x_border+NODE_WIDTH/2+NODE_WIDTH*i),(user_data->dlg.selected_item-first_item)*ITEM_HEIGHT+TOP_Y_BORDER+ITEM_HEIGHT);
1239                                         cairo_stroke(cr);
1240                                         cairo_destroy(cr);
1241                                 }
1242 #endif
1243                         }
1244         }
1245
1246         g_object_unref(G_OBJECT(layout));
1247
1248         /* refresh the draw areas */
1249         if (gtk_widget_is_drawable(user_data->dlg.draw_area_time) ){
1250                 cr = gdk_cairo_create (gtk_widget_get_window(user_data->dlg.draw_area_time));
1251 #if GTK_CHECK_VERSION(2,22,0)
1252                 cairo_set_source_surface (cr, user_data->dlg.surface_time, 0, 0);
1253 #else
1254                 gdk_cairo_set_source_pixmap (cr, user_data->dlg.pixmap_time, 0, 0);
1255 #endif
1256                 cairo_rectangle (cr, 0, 0, draw_area_time_alloc.width, draw_area_time_alloc.height);
1257                 cairo_fill (cr);
1258                 cairo_destroy (cr);
1259                 cr = NULL;
1260         }
1261
1262         if (gtk_widget_is_drawable(user_data->dlg.draw_area) ){
1263                 cr = gdk_cairo_create (gtk_widget_get_window(user_data->dlg.draw_area));
1264 #if GTK_CHECK_VERSION(2,22,0)
1265                 cairo_set_source_surface (cr, user_data->dlg.surface_main, 0, 0);
1266 #else
1267                 gdk_cairo_set_source_pixmap (cr, user_data->dlg.pixmap_main, 0, 0);
1268 #endif
1269                 cairo_rectangle (cr, 0, 0, draw_area_alloc.width, draw_area_alloc.height);
1270                 cairo_fill (cr);
1271                 cairo_destroy (cr);
1272                 cr = NULL;
1273         }
1274
1275         if (gtk_widget_is_drawable(user_data->dlg.draw_area_comments) ){
1276                 cr = gdk_cairo_create (gtk_widget_get_window(user_data->dlg.draw_area_comments));
1277 #if GTK_CHECK_VERSION(2,22,0)
1278                 cairo_set_source_surface (cr, user_data->dlg.surface_comments, 0, 0);
1279 #else
1280                 gdk_cairo_set_source_pixmap (cr, user_data->dlg.pixmap_comments, 0, 0);
1281 #endif
1282                 cairo_rectangle (cr, 0, 0, draw_area_comments_alloc.width, draw_area_comments_alloc.height);
1283                 cairo_fill (cr);
1284                 cairo_destroy (cr);
1285                 cr = NULL;
1286         }
1287
1288         /* update the v_scrollbar */
1289         gtk_adjustment_set_upper(user_data->dlg.v_scrollbar_adjustment, (gdouble) user_data->num_items-1);
1290         gtk_adjustment_set_step_increment(user_data->dlg.v_scrollbar_adjustment, 1);
1291         gtk_adjustment_set_page_increment(user_data->dlg.v_scrollbar_adjustment, (gdouble) (last_item-first_item));
1292         gtk_adjustment_set_page_size(user_data->dlg.v_scrollbar_adjustment, (gdouble) (last_item-first_item));
1293         gtk_adjustment_set_value(user_data->dlg.v_scrollbar_adjustment, (gdouble) first_item);
1294
1295         gtk_adjustment_changed(user_data->dlg.v_scrollbar_adjustment);
1296         gtk_adjustment_value_changed(user_data->dlg.v_scrollbar_adjustment);
1297 }
1298
1299 /****************************************************************************/
1300 static void dialog_graph_redraw(graph_analysis_data_t *user_data)
1301 {
1302         user_data->dlg.needs_redraw=TRUE;
1303         dialog_graph_draw(user_data);
1304 }
1305
1306 /****************************************************************************/
1307 static gboolean button_press_event(GtkWidget *widget _U_, GdkEventButton *event, gpointer data)
1308 {
1309         graph_analysis_data_t *user_data = data;
1310         guint32 item;
1311
1312         if (event->type != GDK_BUTTON_PRESS) return TRUE;
1313
1314         if (event->y<TOP_Y_BORDER) return TRUE;
1315
1316         /* get the item clicked */
1317         item = ((guint32)event->y - TOP_Y_BORDER) / ITEM_HEIGHT;
1318         if (item >= user_data->num_items) return TRUE;
1319         user_data->dlg.selected_item = item + user_data->dlg.first_item;
1320
1321         user_data->dlg.needs_redraw=TRUE;
1322         dialog_graph_draw(user_data);
1323
1324         cf_goto_frame(&cfile, user_data->dlg.items[item].frame_num);
1325
1326         return TRUE;
1327 }
1328
1329 /****************************************************************************/
1330 static gboolean scroll_event(GtkWidget *widget _U_, GdkEventScroll *event, gpointer data)
1331 {
1332         graph_analysis_data_t *user_data = data;
1333
1334         /* Up scroll */
1335         switch(event->direction) {
1336         case(GDK_SCROLL_UP):
1337                 if (user_data->dlg.first_item == 0) return TRUE;
1338                 if (user_data->dlg.first_item < 3)
1339                         user_data->dlg.first_item = 0;
1340                 else
1341                         user_data->dlg.first_item -= 3;
1342                 break;
1343         case(GDK_SCROLL_DOWN):
1344                 if ((user_data->dlg.first_item+gtk_adjustment_get_page_size(user_data->dlg.v_scrollbar_adjustment)+1 == user_data->num_items)) return TRUE;
1345                 if ((user_data->dlg.first_item+gtk_adjustment_get_page_size(user_data->dlg.v_scrollbar_adjustment)+1) > (user_data->num_items-3))
1346                         user_data->dlg.first_item = user_data->num_items-(guint32)gtk_adjustment_get_page_size(user_data->dlg.v_scrollbar_adjustment)-1;
1347                 else
1348                         user_data->dlg.first_item += 3;
1349             break;
1350         case(GDK_SCROLL_LEFT):
1351         case(GDK_SCROLL_RIGHT):
1352                 /* nothing to do */
1353                 break;
1354         }
1355         dialog_graph_redraw(user_data);
1356
1357         return TRUE;
1358 }
1359
1360 /****************************************************************************/
1361 static gboolean key_press_event(GtkWidget *widget _U_, GdkEventKey *event, gpointer data)
1362 {
1363         graph_analysis_data_t *user_data = data;
1364
1365         /* if there is nothing selected, just return */
1366         if (user_data->dlg.selected_item == 0xFFFFFFFF) return TRUE;
1367
1368         /* Up arrow */
1369         if (event->keyval == GDK_Up){
1370                 if (user_data->dlg.selected_item == 0) return TRUE;
1371                 user_data->dlg.selected_item--;
1372                 if ( (user_data->dlg.selected_item<user_data->dlg.first_item) || (user_data->dlg.selected_item>user_data->dlg.first_item+gtk_adjustment_get_page_size(user_data->dlg.v_scrollbar_adjustment)) )
1373                         user_data->dlg.first_item = user_data->dlg.selected_item;
1374                 /* Down arrow */
1375         } else if (event->keyval == GDK_Down){
1376                 if (user_data->dlg.selected_item == user_data->num_items-1) return TRUE;
1377                 user_data->dlg.selected_item++;
1378                 if ( (user_data->dlg.selected_item<user_data->dlg.first_item) || (user_data->dlg.selected_item>user_data->dlg.first_item+gtk_adjustment_get_page_size(user_data->dlg.v_scrollbar_adjustment)) )
1379                         user_data->dlg.first_item = (guint32)user_data->dlg.selected_item-(guint32)gtk_adjustment_get_page_size(user_data->dlg.v_scrollbar_adjustment);
1380         } else if (event->keyval == GDK_Left){
1381                 if (user_data->dlg.first_node == 0) return TRUE;
1382                 user_data->dlg.first_node--;
1383         } else return TRUE;
1384
1385         user_data->dlg.needs_redraw=TRUE;
1386         dialog_graph_draw(user_data);
1387
1388         cf_goto_frame(&cfile, user_data->dlg.items[user_data->dlg.selected_item-user_data->dlg.first_item].frame_num);
1389
1390         return TRUE;
1391 }
1392
1393 /****************************************************************************/
1394 static gboolean expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
1395 {
1396         graph_analysis_data_t *user_data = data;
1397         cairo_t *cr = gdk_cairo_create (gtk_widget_get_window(widget));
1398
1399         if (gtk_widget_is_drawable(widget)){
1400 #if GTK_CHECK_VERSION(2,22,0)
1401                 cairo_set_source_surface (cr, user_data->dlg.surface_main, event->area.x, event->area.y);
1402 #else
1403                 gdk_cairo_set_source_pixmap (cr, user_data->dlg.pixmap_main, event->area.x, event->area.y);
1404 #endif
1405                 cairo_rectangle (cr, event->area.x, event->area.y, event->area.width, event->area.height);
1406                 cairo_fill (cr);
1407
1408                 cairo_destroy (cr);
1409         }
1410
1411         return FALSE;
1412 }
1413
1414 /****************************************************************************/
1415 static gboolean expose_event_comments(GtkWidget *widget, GdkEventExpose *event, gpointer data)
1416 {
1417         graph_analysis_data_t *user_data = data;
1418         cairo_t *cr = gdk_cairo_create (gtk_widget_get_window(widget));
1419
1420         if (gtk_widget_is_drawable(widget)){
1421 #if GTK_CHECK_VERSION(2,22,0)
1422                 cairo_set_source_surface (cr, user_data->dlg.surface_comments, event->area.x, event->area.y);
1423 #else
1424                 gdk_cairo_set_source_pixmap (cr, user_data->dlg.pixmap_comments, event->area.x, event->area.y);
1425 #endif
1426                 cairo_rectangle (cr, event->area.x, event->area.y, event->area.width, event->area.height);
1427                 cairo_fill (cr);
1428
1429                 cairo_destroy (cr);
1430         }
1431
1432         return FALSE;
1433 }
1434
1435 /****************************************************************************/
1436 static gboolean expose_event_time(GtkWidget *widget, GdkEventExpose *event, gpointer data)
1437 {
1438         graph_analysis_data_t *user_data = data;
1439         cairo_t *cr = gdk_cairo_create (gtk_widget_get_window(widget));
1440
1441         if (gtk_widget_is_drawable(widget) ){
1442 #if GTK_CHECK_VERSION(2,22,0)
1443                 cairo_set_source_surface (cr, user_data->dlg.surface_time, event->area.x, event->area.y);
1444 #else
1445                 gdk_cairo_set_source_pixmap (cr, user_data->dlg.pixmap_time, event->area.x, event->area.y);
1446 #endif
1447                 cairo_rectangle (cr, event->area.x, event->area.y, event->area.width, event->area.height);
1448                 cairo_fill (cr);
1449
1450                 cairo_destroy (cr);
1451         }
1452
1453         return FALSE;
1454 }
1455
1456 /****************************************************************************/
1457 static gboolean configure_event(GtkWidget *widget, GdkEventConfigure *event _U_, gpointer data)
1458 {
1459         graph_analysis_data_t *user_data = data;
1460         GtkAllocation widget_alloc;
1461         cairo_t *cr;
1462
1463 #if GTK_CHECK_VERSION(2,22,0)
1464         if(user_data->dlg.surface_main){
1465                 cairo_surface_destroy (user_data->dlg.surface_main);
1466                 user_data->dlg.surface_main=NULL;
1467         }
1468 #else
1469         if(user_data->dlg.pixmap_main){
1470                 g_object_unref(user_data->dlg.pixmap_main);
1471                 user_data->dlg.pixmap_main=NULL;
1472         }
1473 #endif
1474         gtk_widget_get_allocation(widget, &widget_alloc);
1475
1476 #if GTK_CHECK_VERSION(2,22,0)
1477         user_data->dlg.surface_main = gdk_window_create_similar_surface (gtk_widget_get_window(widget),
1478                         CAIRO_CONTENT_COLOR,
1479                         widget_alloc.width,
1480                         widget_alloc.height);
1481
1482         cr = cairo_create (user_data->dlg.surface_main);
1483         cairo_rectangle (cr, 0, 0, widget_alloc.width, widget_alloc.height);
1484         cairo_set_source_rgb (cr, 1, 1, 1);
1485         cairo_fill (cr);
1486         cairo_destroy (cr);
1487         cr = NULL;
1488 #else
1489         user_data->dlg.pixmap_main=gdk_pixmap_new(gtk_widget_get_window(widget),
1490                 widget_alloc.width,
1491                 widget_alloc.height,
1492                 -1);
1493         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_main) ){
1494                 cr = gdk_cairo_create (user_data->dlg.pixmap_main);
1495                 cairo_rectangle (cr, 0, 0, widget_alloc.width, widget_alloc.height);
1496                 cairo_set_source_rgb (cr, 1, 1, 1);
1497                 cairo_fill (cr);
1498                 cairo_destroy (cr);
1499                 cr = NULL;
1500         }
1501 #endif
1502
1503         dialog_graph_redraw(user_data);
1504
1505         return TRUE;
1506 }
1507
1508 /****************************************************************************/
1509 static gboolean configure_event_comments(GtkWidget *widget, GdkEventConfigure *event _U_, gpointer data)
1510 {
1511         graph_analysis_data_t *user_data = data;
1512         GtkAllocation widget_alloc;
1513         cairo_t *cr;
1514
1515         gtk_widget_get_allocation(widget, &widget_alloc);
1516
1517 #if GTK_CHECK_VERSION(2,22,0)
1518         if(user_data->dlg.surface_comments){
1519                 cairo_surface_destroy (user_data->dlg.surface_comments);
1520                 user_data->dlg.surface_comments=NULL;
1521         }
1522 #else
1523         if(user_data->dlg.pixmap_comments){
1524                 g_object_unref(user_data->dlg.pixmap_comments);
1525                 user_data->dlg.pixmap_comments=NULL;
1526         }
1527 #endif
1528
1529 #if GTK_CHECK_VERSION(2,22,0)
1530         user_data->dlg.surface_comments=gdk_window_create_similar_surface (gtk_widget_get_window(widget),
1531                         CAIRO_CONTENT_COLOR,
1532                         widget_alloc.width,
1533                         widget_alloc.height);
1534
1535         cr = cairo_create (user_data->dlg.surface_comments);
1536         cairo_rectangle (cr, 0, 0, widget_alloc.width, widget_alloc.height);
1537         cairo_set_source_rgb (cr, 1, 1, 1);
1538         cairo_fill (cr);
1539         cairo_destroy (cr);
1540         cr = NULL;
1541 #else
1542         user_data->dlg.pixmap_comments=gdk_pixmap_new(gtk_widget_get_window(widget),
1543                                                 widget_alloc.width,
1544                                                 widget_alloc.height,
1545                                                 -1);
1546
1547         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_main) ){
1548                 cr = gdk_cairo_create (user_data->dlg.pixmap_comments);
1549                 cairo_rectangle (cr, 0, 0, widget_alloc.width, widget_alloc.height);
1550                 cairo_set_source_rgb (cr, 1, 1, 1);
1551                 cairo_fill (cr);
1552                 cairo_destroy (cr);
1553                 cr = NULL;
1554         }
1555 #endif
1556         dialog_graph_redraw(user_data);
1557         return TRUE;
1558 }
1559
1560 /****************************************************************************/
1561 static gboolean configure_event_time(GtkWidget *widget, GdkEventConfigure *event _U_, gpointer data)
1562 {
1563         graph_analysis_data_t *user_data = data;
1564         GtkAllocation widget_alloc;
1565         cairo_t *cr;
1566
1567         gtk_widget_get_allocation(widget, &widget_alloc);
1568
1569 #if GTK_CHECK_VERSION(2,22,0)
1570         if(user_data->dlg.surface_time){
1571                 cairo_surface_destroy (user_data->dlg.surface_main);
1572                 user_data->dlg.surface_main=NULL;
1573         }
1574 #else
1575         if(user_data->dlg.pixmap_time){
1576                 g_object_unref(user_data->dlg.pixmap_time);
1577                 user_data->dlg.pixmap_time=NULL;
1578         }
1579 #endif
1580 #if GTK_CHECK_VERSION(2,22,0)
1581         user_data->dlg.surface_time=gdk_window_create_similar_surface(gtk_widget_get_window(widget),
1582                         CAIRO_CONTENT_COLOR,
1583                         widget_alloc.width,
1584                         widget_alloc.height);
1585
1586         cr = cairo_create (user_data->dlg.surface_time);
1587         cairo_rectangle (cr, 0, 0, widget_alloc.width, widget_alloc.height);
1588         cairo_set_source_rgb (cr, 1, 1, 1);
1589         cairo_fill (cr);
1590         cairo_destroy (cr);
1591         cr = NULL;
1592 #else
1593         user_data->dlg.pixmap_time=gdk_pixmap_new(gtk_widget_get_window(widget),
1594                                                 widget_alloc.width,
1595                                                 widget_alloc.height,
1596                                                 -1);
1597
1598         if ( GDK_IS_DRAWABLE(user_data->dlg.pixmap_time) ){
1599                 cr = gdk_cairo_create (user_data->dlg.pixmap_time);
1600                 cairo_rectangle (cr, 0, 0, widget_alloc.width, widget_alloc.height);
1601                 cairo_set_source_rgb (cr, 1, 1, 1);
1602                 cairo_fill (cr);
1603                 cairo_destroy (cr);
1604                 cr = NULL;
1605         }
1606 #endif
1607
1608         dialog_graph_redraw(user_data);
1609
1610         return TRUE;
1611 }
1612
1613 /****************************************************************************/
1614 static gboolean pane_callback(GtkWidget *widget _U_, GParamSpec *pspec _U_, gpointer data)
1615 {
1616         graph_analysis_data_t *user_data = data;
1617         GtkAllocation draw_area_comments_alloc;
1618         cairo_t *cr;
1619
1620         if (gtk_paned_get_position(GTK_PANED(user_data->dlg.hpane)) > user_data->dlg.surface_width)
1621                 gtk_paned_set_position(GTK_PANED(user_data->dlg.hpane), user_data->dlg.surface_width);
1622         else if (gtk_paned_get_position(GTK_PANED(user_data->dlg.hpane)) < NODE_WIDTH*2)
1623                 gtk_paned_set_position(GTK_PANED(user_data->dlg.hpane), NODE_WIDTH*2);
1624
1625         /* repaint the comment area because when moving the pane position there are times that the expose_event_comments is not called */
1626
1627         gtk_widget_get_allocation(user_data->dlg.draw_area_comments, &draw_area_comments_alloc);
1628
1629         if (gtk_widget_is_drawable(user_data->dlg.draw_area_comments)){
1630                 cr = gdk_cairo_create (gtk_widget_get_window(user_data->dlg.draw_area_comments));
1631 #if GTK_CHECK_VERSION(2,22,0)
1632                 cairo_set_source_surface (cr, user_data->dlg.surface_comments, 0, 0);
1633 #else
1634                 gdk_cairo_set_source_pixmap (cr, user_data->dlg.pixmap_comments, 0, 0);
1635 #endif
1636                 cairo_rectangle (cr, 0, 0, draw_area_comments_alloc.width, draw_area_comments_alloc.height);
1637                 cairo_fill (cr);
1638                 cairo_destroy (cr);
1639         }
1640
1641         return TRUE;
1642 }
1643
1644 /****************************************************************************/
1645 static void v_scrollbar_changed(GtkWidget *widget _U_, gpointer data)
1646 {
1647         graph_analysis_data_t *user_data = data;
1648
1649         if ((user_data->dlg.first_item+gtk_adjustment_get_page_size(user_data->dlg.v_scrollbar_adjustment)+1 == user_data->num_items)
1650             && (gtk_adjustment_get_value(user_data->dlg.v_scrollbar_adjustment) >= user_data->dlg.first_item ))
1651                 return;
1652
1653         if (user_data->dlg.first_item == gtk_adjustment_get_value(user_data->dlg.v_scrollbar_adjustment))
1654                 return;
1655
1656         user_data->dlg.first_item = (guint32) gtk_adjustment_get_value(user_data->dlg.v_scrollbar_adjustment);
1657
1658         dialog_graph_redraw(user_data);
1659
1660         return;
1661 }
1662
1663 /****************************************************************************/
1664 static void create_draw_area(graph_analysis_data_t *user_data, GtkWidget *box)
1665 {
1666         GtkWidget *hbox;
1667         GtkWidget *viewport;
1668         GtkWidget *scroll_window_comments;
1669         GtkWidget *viewport_comments;
1670         GtkWidget *frame_time;
1671         GtkWidget *scroll_vbox;
1672         GtkWidget *frame_box;
1673         GtkRequisition scroll_requisition;
1674         GtkWidget *frame;
1675
1676         hbox=gtk_hbox_new(FALSE, 0);
1677         gtk_widget_show(hbox);
1678
1679         /* create "time" draw area */
1680         user_data->dlg.draw_area_time=gtk_drawing_area_new();
1681         gtk_widget_set_size_request(user_data->dlg.draw_area_time, TIME_WIDTH, user_data->dlg.surface_width);
1682         frame_time = gtk_frame_new(NULL);
1683         gtk_widget_show(frame_time);
1684         gtk_container_add(GTK_CONTAINER(frame_time),user_data->dlg.draw_area_time);
1685
1686         /* create "comments" draw area */
1687         user_data->dlg.draw_area_comments=gtk_drawing_area_new();
1688         gtk_widget_set_size_request(user_data->dlg.draw_area_comments, COMMENT_WIDTH, user_data->dlg.surface_width);
1689         scroll_window_comments=gtk_scrolled_window_new(NULL, NULL);
1690         gtk_widget_set_size_request(scroll_window_comments, (gint)(COMMENT_WIDTH/1.5), user_data->dlg.surface_width);
1691         /*
1692          * Set the scrollbar policy for the horizontal and vertical scrollbars
1693          * The policy determines when the scrollbar should appear
1694          */
1695         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scroll_window_comments),
1696                 GTK_POLICY_ALWAYS, /* Policy for horizontal bar. */
1697                 GTK_POLICY_NEVER); /* Policy for vertical bar */
1698
1699         /* Changes the type of shadow drawn around the contents of scrolled_window. */
1700         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll_window_comments),
1701                 GTK_SHADOW_ETCHED_IN);
1702
1703         viewport_comments = gtk_viewport_new(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(scroll_window_comments)),
1704                                              gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(scroll_window_comments)));
1705         gtk_container_add(GTK_CONTAINER(viewport_comments), user_data->dlg.draw_area_comments);
1706         gtk_container_add(GTK_CONTAINER(scroll_window_comments), viewport_comments);
1707         gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport_comments), GTK_SHADOW_NONE);
1708         gtk_widget_add_events (user_data->dlg.draw_area_comments, GDK_BUTTON_PRESS_MASK);
1709         g_signal_connect(user_data->dlg.draw_area_comments, "scroll_event",  G_CALLBACK(scroll_event), user_data);
1710
1711         /* create main Graph draw area */
1712         user_data->dlg.draw_area=gtk_drawing_area_new();
1713         if (user_data->num_nodes < 2)
1714                 user_data->dlg.surface_width = 2 * NODE_WIDTH;
1715         else
1716                 user_data->dlg.surface_width = user_data->num_nodes * NODE_WIDTH;
1717         gtk_widget_set_size_request(user_data->dlg.draw_area, user_data->dlg.surface_width, user_data->dlg.surface_width);
1718         user_data->dlg.scroll_window=gtk_scrolled_window_new(NULL, NULL);
1719         if ( user_data->num_nodes < 6)
1720                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*user_data->num_nodes, user_data->dlg.surface_width);
1721         else
1722                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*5, user_data->dlg.surface_width);
1723
1724         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW(user_data->dlg.scroll_window),
1725                 GTK_POLICY_ALWAYS,
1726                 GTK_POLICY_NEVER);
1727
1728         gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(user_data->dlg.scroll_window),
1729                 GTK_SHADOW_ETCHED_IN);
1730         viewport = gtk_viewport_new(gtk_scrolled_window_get_hadjustment(GTK_SCROLLED_WINDOW(user_data->dlg.scroll_window)),
1731                                     gtk_scrolled_window_get_vadjustment(GTK_SCROLLED_WINDOW(user_data->dlg.scroll_window)));
1732         gtk_container_add(GTK_CONTAINER(viewport), user_data->dlg.draw_area);
1733         gtk_container_add(GTK_CONTAINER(user_data->dlg.scroll_window), viewport);
1734         gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
1735 #if GTK_CHECK_VERSION(2,18,0)
1736         gtk_widget_set_can_focus(user_data->dlg.draw_area, TRUE);
1737 #else
1738         GTK_WIDGET_SET_FLAGS(user_data->dlg.draw_area, GTK_CAN_FOCUS);
1739 #endif
1740         gtk_widget_grab_focus(user_data->dlg.draw_area);
1741
1742         /* signals needed to handle backing pixmap */
1743         g_signal_connect(user_data->dlg.draw_area, "expose_event", G_CALLBACK(expose_event), user_data);
1744         g_signal_connect(user_data->dlg.draw_area, "configure_event", G_CALLBACK(configure_event), user_data);
1745
1746         /* signals needed to handle backing pixmap comments */
1747         g_signal_connect(user_data->dlg.draw_area_comments, "expose_event", G_CALLBACK(expose_event_comments), user_data);
1748         g_signal_connect(user_data->dlg.draw_area_comments, "configure_event", G_CALLBACK(configure_event_comments), user_data);
1749
1750         /* signals needed to handle backing pixmap time */
1751         g_signal_connect(user_data->dlg.draw_area_time, "expose_event", G_CALLBACK(expose_event_time), user_data);
1752         g_signal_connect(user_data->dlg.draw_area_time, "configure_event", G_CALLBACK(configure_event_time), user_data);
1753
1754         gtk_widget_add_events (user_data->dlg.draw_area, GDK_BUTTON_PRESS_MASK);
1755         g_signal_connect(user_data->dlg.draw_area, "button_press_event", G_CALLBACK(button_press_event), user_data);
1756         g_signal_connect(user_data->dlg.draw_area, "scroll_event",  G_CALLBACK(scroll_event), user_data);
1757         g_signal_connect(user_data->dlg.draw_area, "key_press_event",  G_CALLBACK(key_press_event), user_data);
1758
1759         gtk_widget_show(user_data->dlg.draw_area_time);
1760         gtk_widget_show(user_data->dlg.draw_area);
1761         gtk_widget_show(viewport);
1762         gtk_widget_show(user_data->dlg.draw_area_comments);
1763         gtk_widget_show(viewport_comments);
1764
1765         gtk_widget_show(user_data->dlg.scroll_window);
1766         gtk_widget_show(scroll_window_comments);
1767
1768         gtk_box_pack_start(GTK_BOX(hbox), frame_time, FALSE, FALSE, 3);
1769
1770         user_data->dlg.hpane = gtk_hpaned_new();
1771         gtk_paned_pack1(GTK_PANED (user_data->dlg.hpane), user_data->dlg.scroll_window, FALSE, TRUE);
1772         gtk_paned_pack2(GTK_PANED (user_data->dlg.hpane), scroll_window_comments, TRUE, TRUE);
1773         g_signal_connect(user_data->dlg.hpane, "notify::position",  G_CALLBACK(pane_callback), user_data);
1774         gtk_widget_show(user_data->dlg.hpane);
1775
1776         gtk_box_pack_start(GTK_BOX(hbox), user_data->dlg.hpane, TRUE, TRUE, 0);
1777
1778         /* Create the scroll_vbox to include the vertical scroll and a box at the bottom */
1779         scroll_vbox=gtk_vbox_new(FALSE, 0);
1780         gtk_widget_show(scroll_vbox);
1781
1782         /* create the associated v_scrollbar */
1783         user_data->dlg.v_scrollbar_adjustment=(GtkAdjustment *)gtk_adjustment_new(0,0,0,0,0,0);
1784         user_data->dlg.v_scrollbar=gtk_vscrollbar_new(user_data->dlg.v_scrollbar_adjustment);
1785         gtk_widget_show(user_data->dlg.v_scrollbar);
1786         gtk_box_pack_start(GTK_BOX(scroll_vbox), user_data->dlg.v_scrollbar, TRUE, TRUE, 0);
1787         g_signal_connect(user_data->dlg.v_scrollbar_adjustment, "value_changed",
1788                          G_CALLBACK(v_scrollbar_changed), user_data);
1789
1790         frame_box = gtk_frame_new(NULL);
1791         gtk_widget_size_request(user_data->dlg.v_scrollbar, &scroll_requisition);
1792         gtk_widget_set_size_request(frame_box, 1, scroll_requisition.width+2);
1793         gtk_frame_set_shadow_type(GTK_FRAME(frame_box), GTK_SHADOW_NONE);
1794         gtk_widget_show(frame_box);
1795         gtk_box_pack_end(GTK_BOX(scroll_vbox), frame_box, FALSE, FALSE, 0);
1796         gtk_box_pack_end(GTK_BOX(hbox), scroll_vbox, FALSE, FALSE, 3);
1797
1798         /* Frame around the main area */
1799         frame = gtk_frame_new(NULL);
1800         gtk_widget_show(frame);
1801         gtk_container_add(GTK_CONTAINER(frame), hbox);
1802         gtk_container_set_border_width(GTK_CONTAINER(hbox), 3);
1803
1804         /*gtk_box_pack_start(GTK_BOX(box), hbox, TRUE, TRUE, 15);*/
1805         /*gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 15);*/
1806         gtk_box_pack_start(GTK_BOX(box), frame, TRUE, TRUE, 0);
1807         gtk_container_set_border_width(GTK_CONTAINER(box), 10);
1808 }
1809 /****************************************************************************/
1810 /* PUBLIC */
1811 /****************************************************************************/
1812
1813
1814 /****************************************************************************/
1815 static void dialog_graph_create_window(graph_analysis_data_t *user_data)
1816 {
1817         GtkWidget *vbox;
1818         GtkWidget *hbuttonbox;
1819         GtkWidget *bt_close;
1820         GtkWidget *bt_save;
1821         const gchar *title_name_ptr;
1822         gchar   *win_name;
1823
1824         title_name_ptr = cf_get_display_name(&cfile);
1825         win_name = g_strdup_printf("%s - Graph Analysis", title_name_ptr);
1826
1827         /* create the main window */
1828         user_data->dlg.window=dlg_window_new((user_data->dlg.title)?user_data->dlg.title:win_name);
1829         gtk_window_set_destroy_with_parent(GTK_WINDOW(user_data->dlg.window), TRUE);
1830
1831         vbox=gtk_vbox_new(FALSE, 0);
1832         gtk_container_add(GTK_CONTAINER(user_data->dlg.window), vbox);
1833         gtk_widget_show(vbox);
1834
1835         create_draw_area(user_data, vbox);
1836
1837         /* button row */
1838         hbuttonbox = gtk_hbutton_box_new ();
1839         gtk_box_pack_start (GTK_BOX (vbox), hbuttonbox, FALSE, FALSE, 10);
1840         gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox), GTK_BUTTONBOX_SPREAD);
1841         gtk_box_set_spacing (GTK_BOX (hbuttonbox), 30);
1842         gtk_widget_show(hbuttonbox);
1843
1844         bt_save = gtk_button_new_from_stock(GTK_STOCK_SAVE_AS);
1845         gtk_container_add(GTK_CONTAINER(hbuttonbox), bt_save);
1846         gtk_widget_show(bt_save);
1847         g_signal_connect(bt_save, "clicked", G_CALLBACK(on_save_bt_clicked), user_data);
1848         gtk_widget_set_tooltip_text(bt_save, "Save an ASCII representation of the graph to a file");
1849
1850         bt_close = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
1851         gtk_container_add (GTK_CONTAINER (hbuttonbox), bt_close);
1852 #if GTK_CHECK_VERSION(2,18,0)
1853         gtk_widget_set_can_default(bt_close, TRUE);
1854 #else
1855         GTK_WIDGET_SET_FLAGS(bt_close, GTK_CAN_DEFAULT);
1856 #endif
1857         gtk_widget_show(bt_close);
1858         gtk_widget_set_tooltip_text(bt_close, "Close this dialog");
1859         window_set_cancel_button(user_data->dlg.window, bt_close, window_cancel_button_cb);
1860
1861         g_signal_connect(user_data->dlg.window, "delete_event", G_CALLBACK(window_delete_event_cb), NULL);
1862         g_signal_connect(user_data->dlg.window, "destroy", G_CALLBACK(on_destroy), user_data);
1863
1864         gtk_widget_show(user_data->dlg.window);
1865         window_present(user_data->dlg.window);
1866
1867         /* Destroy our graph window with our parent if the caller specified the parent */
1868         if(user_data->dlg.parent_w) {
1869                 gtk_window_set_transient_for(GTK_WINDOW(user_data->dlg.window),
1870                                              GTK_WINDOW(user_data->dlg.parent_w));
1871                 /* Destruction of this child window */
1872                 gtk_window_set_destroy_with_parent(GTK_WINDOW(user_data->dlg.window), TRUE);
1873         }
1874         g_free(win_name);
1875 }
1876
1877 /* Return the index array if the node is in the array. Return -1 if there is room in the array
1878  * and Return -2 if the array is full
1879  */
1880 /****************************************************************************/
1881 static gint add_or_get_node(graph_analysis_data_t *user_data, address *node) {
1882         guint i;
1883
1884         if (node->type == AT_NONE) return NODE_OVERFLOW;
1885
1886         for (i=0; i<MAX_NUM_NODES && i < user_data->num_nodes ; i++){
1887                 if ( CMP_ADDRESS(&(user_data->nodes[i]), node) == 0 ) return i; /* it is in the array */
1888         }
1889
1890         if (i == MAX_NUM_NODES) {
1891                 return  NODE_OVERFLOW;
1892         } else {
1893                 user_data->num_nodes++;
1894                 COPY_ADDRESS(&(user_data->nodes[i]),node);
1895                 return i;
1896         }
1897 }
1898
1899 /* Get the nodes from the list */
1900 /****************************************************************************/
1901 static void get_nodes(graph_analysis_data_t *user_data)
1902 {
1903         GList *list;
1904         graph_analysis_item_t *gai;
1905
1906         /* fill the node array */
1907         list = g_list_first(user_data->graph_info->list);
1908         while (list)
1909         {
1910                 gai = list->data;
1911                 if (gai->display) {
1912                         user_data->num_items++;
1913                         if (!user_data->dlg.inverse) {
1914                                 gai->src_node = (guint16)add_or_get_node(user_data, &(gai->src_addr));
1915                                 gai->dst_node = (guint16)add_or_get_node(user_data, &(gai->dst_addr));
1916                         } else {
1917                                 gai->dst_node = (guint16)add_or_get_node(user_data, &(gai->src_addr));
1918                                 gai->src_node = (guint16)add_or_get_node(user_data, &(gai->dst_addr));
1919                         }
1920                 }
1921                 list = g_list_next(list);
1922         }
1923 }
1924
1925 /****************************************************************************/
1926 graph_analysis_data_t *graph_analysis_init(void)
1927 {
1928         graph_analysis_data_t *user_data;
1929         /* init */
1930         user_data = g_malloc(sizeof(graph_analysis_data_t));
1931
1932         /* init user_data */
1933         graph_analysis_init_dlg(user_data);
1934
1935         return user_data;
1936 }
1937 /****************************************************************************/
1938 /* PUBLIC */
1939 /****************************************************************************/
1940
1941 /****************************************************************************/
1942 void graph_analysis_create(graph_analysis_data_t *user_data)
1943 {
1944         /* reset the data */
1945         graph_analysis_reset(user_data);
1946
1947         /* get nodes (each node is an address) */
1948         get_nodes(user_data);
1949
1950         /* create the graph windows */
1951         dialog_graph_create_window(user_data);
1952
1953         /* redraw the graph */
1954         dialog_graph_redraw(user_data);
1955
1956         return;
1957 }
1958
1959 /****************************************************************************/
1960 void graph_analysis_update(graph_analysis_data_t *user_data)
1961 {
1962         /* reset the data */
1963         graph_analysis_reset(user_data);
1964
1965         /* get nodes (each node is an address) */
1966         get_nodes(user_data);
1967
1968         user_data->dlg.surface_width = user_data->num_nodes * NODE_WIDTH;
1969         gtk_widget_set_size_request(user_data->dlg.draw_area, user_data->dlg.surface_width, user_data->dlg.surface_width);
1970         if (user_data->num_nodes < 6)
1971                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*user_data->num_nodes, user_data->dlg.surface_width);
1972         else
1973                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*5, user_data->dlg.surface_width);
1974
1975         /* redraw the graph */
1976         dialog_graph_redraw(user_data);
1977
1978         window_present(user_data->dlg.window);
1979         return;
1980 }
1981
1982
1983 /****************************************************************************/
1984 void graph_analysis_redraw(graph_analysis_data_t *user_data)
1985 {
1986         /* get nodes (each node is an address) */
1987         get_nodes(user_data);
1988
1989         user_data->dlg.surface_width = user_data->num_nodes * NODE_WIDTH;
1990         gtk_widget_set_size_request(user_data->dlg.draw_area, user_data->dlg.surface_width, user_data->dlg.surface_width);
1991         if (user_data->num_nodes < 6)
1992                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*user_data->num_nodes, user_data->dlg.surface_width);
1993         else
1994                 gtk_widget_set_size_request(user_data->dlg.scroll_window, NODE_WIDTH*5, user_data->dlg.surface_width);
1995
1996
1997         /* redraw the graph */
1998         dialog_graph_redraw(user_data);
1999
2000         window_present(user_data->dlg.window);
2001         return;
2002 }