gtk/sctp_graph_dlg.c

   1 /*
   2  * Copyright 2004, Irene Ruengeler <i.ruengeler [AT] fh-muenster.de>
   3  *
   4  * $Id$
   5  *
   6  * Wireshark - Network traffic analyzer
   7  * By Gerald Combs <gerald@wireshark.org>
   8  * Copyright 1998 Gerald Combs
   9  *
  10  * This program is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU General Public License
  12  * as published by the Free Software Foundation; either version 2
  13  * of the License, or (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  23  */
  24
  25 #ifdef HAVE_CONFIG_H
  26 #  include <config.h>
  27 #endif
  28
  29
  30 #include <gtk/gtk.h>
  31 #include <gdk/gdk.h>
  32 #include <stdio.h>
  33 #include <stdlib.h>
  34 #include <math.h>
  35 #include <string.h>
  36 #include "globals.h"
  37 #include "epan/filesystem.h"
  38 #include "../color.h"
  39 #include "dlg_utils.h"
  40 #include "ui_util.h"
  41 #include "main.h"
  42 #include "compat_macros.h"
  43 #include "simple_dialog.h"
  44 #include "sctp_stat.h"
  45 #include <epan/strutil.h>
  46
  47 #define DEFAULT_PIXELS_PER_TICK 2
  48 #define MAX_PIXELS_PER_TICK 4
  49 #define AUTO_MAX_YSCALE 0
  50 #define MAX_TICK_VALUES 5
  51 #define DEFAULT_TICK_VALUE 3
  52 #define MAX_YSCALE 22
  53 #define MAX_COUNT_TYPES 3
  54
  55 #define COUNT_TYPE_FRAMES   0
  56 #define COUNT_TYPE_BYTES    1
  57 #define COUNT_TYPE_ADVANCED 2
  58
  59 #define LEFT_BORDER 60
  60 #define RIGHT_BORDER 10
  61 #define TOP_BORDER 10
  62 #define BOTTOM_BORDER 50
  63
  64 #define SUB_32(a, b)    a-b
  65 #define POINT_SIZE      3
  66
  67 struct chunk_header {
  68         guint8  type;
  69         guint8  flags;
  70         guint16 length;
  71 };
  72
  73 struct data_chunk_header {
  74         guint8  type;
  75         guint8  flags;
  76         guint16 length;
  77         guint32 tsn;
  78         guint16 sid;
  79         guint16 ssn;
  80         guint32 ppi;
  81 };
  82
  83 struct init_chunk_header {
  84         guint8  type;
  85         guint8  flags;
  86         guint16 length;
  87         guint32 initiate_tag;
  88         guint32 a_rwnd;
  89         guint16 mos;
  90         guint16 mis;
  91         guint32 initial_tsn;
  92 };
  93
  94 struct gaps {
  95         guint16 start;
  96         guint16 end;
  97 };
  98
  99 struct sack_chunk_header {
 100         guint8  type;
 101         guint8  flags;
 102         guint16 length;
 103         guint32 cum_tsn_ack;
 104         guint32 a_rwnd;
 105         guint16 nr_of_gaps;
 106         guint16 nr_of_dups;
 107         struct gaps gaps[1];
 108 };
 109
 110
 111 static gboolean label_set = FALSE;
 112 static guint32 max_tsn=0, min_tsn=0;
 113 static void sctp_graph_set_title(struct sctp_udata *u_data);
 114 static void create_draw_area(GtkWidget *box, struct sctp_udata *u_data);
 115 static GtkWidget *zoomout_bt;
 116 #if defined(_WIN32) && !defined(__MINGW32__)
 117 static int rint (double );      /* compiler template for Windows */
 118 #endif
 119
 120 static void draw_sack_graph(struct sctp_udata *u_data)
 121 {
 122         tsn_t   *sack;
 123         GList *list=NULL, *tlist;
 124         guint16 gap_start=0, gap_end=0, i, j, nr;
 125         guint8 type;
 126         guint32 tsnumber;
 127         gint xvalue, yvalue;
 128         GdkColor red_color = {0, 65535, 0, 0};
 129         GdkColor green_color = {0, 0, 65535, 0};
 130         GdkGC *red_gc, *green_gc;
 131         struct sack_chunk_header *sack_header;
 132         struct gaps *gap;
 133         guint32 max_num, diff;
 134
 135         red_gc = gdk_gc_new(u_data->io->draw_area->window);
 136         gdk_gc_set_rgb_fg_color(red_gc, &red_color);
 137
 138         green_gc = gdk_gc_new(u_data->io->draw_area->window);
 139         gdk_gc_set_rgb_fg_color(green_gc, &green_color);
 140
 141         if (u_data->dir==2)
 142         {
 143
 144                 list = g_list_last(u_data->assoc->sack2);
 145                 if (u_data->io->tmp==FALSE)
 146                 {
 147                         min_tsn=u_data->assoc->min_tsn2;
 148                         max_tsn=u_data->assoc->max_tsn2;
 149                 }
 150                 else
 151                 {
 152                         min_tsn=u_data->assoc->min_tsn2+u_data->io->tmp_min_tsn2;
 153                         max_tsn=u_data->assoc->min_tsn2+u_data->io->tmp_max_tsn2;
 154                 }
 155         }
 156         else if (u_data->dir==1)
 157         {
 158                 list = g_list_last(u_data->assoc->sack1);
 159                 if (u_data->io->tmp==FALSE)
 160                 {
 161                         min_tsn=u_data->assoc->min_tsn1;
 162                         max_tsn=u_data->assoc->max_tsn1;
 163                 }
 164                 else
 165                 {
 166                         min_tsn=u_data->assoc->min_tsn1+u_data->io->tmp_min_tsn1;
 167                         max_tsn=u_data->assoc->min_tsn1+u_data->io->tmp_max_tsn1;
 168                 }
 169         }
 170
 171         while (list)
 172         {
 173                 sack = (tsn_t*) (list->data);
 174                 tlist = g_list_first(sack->tsns);
 175                 while (tlist)
 176                 {
 177                         type = ((struct chunk_header *)tlist->data)->type;
 178
 179                         if (type == SCTP_SACK_CHUNK_ID)
 180                         {
 181                                 sack_header =(struct sack_chunk_header *)tlist->data;
 182                                 nr=g_ntohs(sack_header->nr_of_gaps);
 183                                 tsnumber = g_ntohl(sack_header->cum_tsn_ack);
 184
 185                                 if (sack->secs>=u_data->io->x1_tmp_sec)
 186                                 {
 187                                         if (nr>0)
 188                                         {
 189                                                 gap = &sack_header->gaps[0];
 190                                                 for(i=0;i<nr; i++)
 191                                                 {
 192                                                         gap_start=g_ntohs(gap->start);
 193                                                         gap_end = g_ntohs(gap->end);
 194                                                         max_num=gap_end+tsnumber;
 195                                                         for (j=gap_start; j<=gap_end; j++)
 196                                                         {
 197                                                                 if (u_data->io->uoff)
 198                                                                         diff = sack->secs - u_data->io->min_x;
 199                                                                 else
 200                                                                         diff=sack->secs*1000000+sack->usecs-u_data->io->min_x;
 201                                                                 xvalue = (guint32)(LEFT_BORDER+u_data->io->offset+u_data->io->x_interval*diff);
 202                                                                 yvalue = (guint32)(u_data->io->pixmap_height-BOTTOM_BORDER-POINT_SIZE-u_data->io->offset-((SUB_32(j+tsnumber,min_tsn))*u_data->io->y_interval));
 203                                                                 if (xvalue >= LEFT_BORDER+u_data->io->offset &&
 204                                                                     xvalue <= u_data->io->pixmap_width-RIGHT_BORDER+u_data->io->offset &&
 205                                                                     yvalue >= TOP_BORDER-u_data->io->offset &&
 206                                                                     yvalue <= u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset)
 207                                                                         gdk_draw_arc(u_data->io->pixmap,green_gc,TRUE,
 208                                                                                     xvalue,
 209                                                                                     yvalue,
 210                                                                                     POINT_SIZE, POINT_SIZE,0, (64*360) );
 211                                                         }
 212                                                         if (i < nr-1)
 213                                                                 gap++;
 214                                                 }
 215                                         }
 216                                         else
 217                                                 max_num=tsnumber;
 218                                         if (tsnumber>=min_tsn)
 219                                         {
 220                                                 if (u_data->io->uoff)
 221                                                         diff = sack->secs - u_data->io->min_x;
 222                                                 else
 223                                                         diff=sack->secs*1000000+sack->usecs-u_data->io->min_x;
 224                                                 xvalue = (guint32)(LEFT_BORDER+u_data->io->offset+u_data->io->x_interval*diff);
 225                                                 yvalue = (guint32)(u_data->io->pixmap_height-BOTTOM_BORDER-POINT_SIZE -u_data->io->offset-((SUB_32(tsnumber,min_tsn))*u_data->io->y_interval));
 226                                                 if (xvalue >= LEFT_BORDER+u_data->io->offset &&
 227                                                     xvalue <= u_data->io->pixmap_width-RIGHT_BORDER+u_data->io->offset &&
 228                                                     yvalue >= TOP_BORDER-u_data->io->offset &&
 229                                                     yvalue <= u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset)
 230                                                         gdk_draw_arc(u_data->io->pixmap,red_gc,TRUE,
 231                                                                      xvalue,
 232                                                                      yvalue,
 233                                                                      POINT_SIZE, POINT_SIZE,0, (64*360) );
 234                                         }
 235                                 }
 236                         tlist = g_list_next(tlist);
 237                         }
 238                 }
 239                 list = g_list_previous(list);
 240         }
 241         g_object_unref(G_OBJECT(red_gc));
 242         g_object_unref(G_OBJECT(green_gc));
 243 }
 244
 245
 246 static void draw_tsn_graph(struct sctp_udata *u_data)
 247 {
 248         tsn_t *tsn;
 249         GList *list=NULL, *tlist;
 250         guint8 type;
 251         guint32 tsnumber=0;
 252         guint32 min_secs=0, diff;
 253         gint xvalue, yvalue;
 254
 255         if (u_data->dir==1)
 256         {
 257                 list = g_list_last(u_data->assoc->tsn1);
 258                 if (u_data->io->tmp==FALSE)
 259                 {
 260                         min_tsn=u_data->assoc->min_tsn1;
 261                         max_tsn=u_data->assoc->max_tsn1;
 262                 }
 263                 else
 264                 {
 265                         min_tsn=u_data->assoc->min_tsn1+u_data->io->tmp_min_tsn1;
 266                         max_tsn=u_data->assoc->min_tsn1+u_data->io->tmp_max_tsn1;
 267                 }
 268         }
 269         else if (u_data->dir==2)
 270         {
 271                 list = g_list_last(u_data->assoc->tsn2);
 272                 if (u_data->io->tmp==FALSE)
 273                 {
 274                         min_tsn=u_data->assoc->min_tsn2;
 275                         max_tsn=u_data->assoc->max_tsn2;
 276                 }
 277                 else
 278                 {
 279                         min_tsn=u_data->assoc->min_tsn2+u_data->io->tmp_min_tsn2;
 280                         max_tsn=u_data->assoc->min_tsn2+u_data->io->tmp_max_tsn2;
 281                 }
 282         }
 283
 284         while (list)
 285         {
 286                 tsn = (tsn_t*) (list->data);
 287                 tlist = g_list_first(tsn->tsns);
 288                 while (tlist)
 289                 {
 290                         type = ((struct chunk_header *)tlist->data)->type;
 291                         if (type == SCTP_DATA_CHUNK_ID)
 292                                 tsnumber = g_ntohl(((struct data_chunk_header *)tlist->data)->tsn);
 293                         if (tsnumber>=min_tsn && tsnumber<=max_tsn && tsn->secs>=min_secs)
 294                         {
 295                                         if (u_data->io->uoff)
 296                                                 diff = tsn->secs - u_data->io->min_x;
 297                                         else
 298                                                 diff=tsn->secs*1000000+tsn->usecs-u_data->io->min_x;
 299                                         xvalue = (guint32)(LEFT_BORDER+u_data->io->offset+u_data->io->x_interval*diff);
 300                                         yvalue = (guint32)(u_data->io->pixmap_height-BOTTOM_BORDER-POINT_SIZE-u_data->io->offset-((SUB_32(tsnumber,min_tsn))*u_data->io->y_interval));
 301                                         if (xvalue >= LEFT_BORDER+u_data->io->offset &&
 302                                             xvalue <= u_data->io->pixmap_width-RIGHT_BORDER+u_data->io->offset &&
 303                                             yvalue >= TOP_BORDER-u_data->io->offset &&
 304                                             yvalue <= u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset)
 305                                                 gdk_draw_arc(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,TRUE,
 306                                                              xvalue,
 307                                                              yvalue,
 308                                                              POINT_SIZE, POINT_SIZE, 0, (64*360));
 309                         }
 310                         tlist = g_list_next(tlist);
 311                 }
 312                 list = g_list_previous(list);
 313         }
 314 }
 315
 316
 317 static void sctp_graph_draw(struct sctp_udata *u_data)
 318 {
 319         int length, lwidth;
 320         guint32  distance=5, i, e, sec, w, start, a, b, j;
 321         gint label_width, label_height;
 322         char label_string[15];
 323         gfloat dis;
 324         gboolean write_label = FALSE;
 325         PangoLayout  *layout;
 326
 327         if (u_data->io->x1_tmp_sec==0 && u_data->io->x1_tmp_usec==0)
 328                 u_data->io->offset=0;
 329         else
 330                 u_data->io->offset=5;
 331
 332         if (u_data->io->x2_tmp_sec - u_data->io->x1_tmp_sec > 1500)
 333         {
 334                 u_data->io->min_x=u_data->io->x1_tmp_sec;
 335                 u_data->io->max_x=u_data->io->x2_tmp_sec;
 336                 u_data->io->uoff = TRUE;
 337         }
 338         else
 339         {
 340                 u_data->io->min_x=(guint32)(u_data->io->x1_tmp_sec*1000000.0+u_data->io->x1_tmp_usec);
 341                 u_data->io->max_x=(guint32)(u_data->io->x2_tmp_sec*1000000.0+u_data->io->x2_tmp_usec);
 342                 u_data->io->uoff = FALSE;
 343         }
 344
 345         u_data->io->tmp_width=u_data->io->max_x-u_data->io->min_x;
 346
 347         if (u_data->dir==1)
 348         {
 349                 if (u_data->io->tmp==FALSE)
 350                 {
 351                         if (u_data->assoc->tsn1!=NULL || u_data->assoc->sack1!=NULL)
 352                                 u_data->io->max_y=u_data->io->tmp_max_tsn1 - u_data->io->tmp_min_tsn1;
 353                         else
 354                                 u_data->io->max_y= 0;
 355                         u_data->io->min_y = 0;
 356                 }
 357                 else
 358                 {
 359                         u_data->io->max_y = u_data->io->tmp_max_tsn1;
 360                         u_data->io->min_y = u_data->io->tmp_min_tsn1;
 361                 }
 362         }
 363         else if (u_data->dir==2)
 364         {
 365                 if (u_data->io->tmp==FALSE)
 366                 {
 367                         if (u_data->assoc->tsn2!=NULL || u_data->assoc->sack2!=NULL)
 368                                         u_data->io->max_y=u_data->io->tmp_max_tsn2 -u_data->io->tmp_min_tsn2;
 369                         else
 370                                 u_data->io->max_y= 0;
 371                         u_data->io->min_y = 0;
 372                 }
 373                 else
 374                 {
 375                         u_data->io->max_y = u_data->io->tmp_max_tsn2;
 376                         u_data->io->min_y = u_data->io->tmp_min_tsn2;
 377                 }
 378         }
 379
 380         gdk_draw_rectangle(u_data->io->pixmap,
 381                            u_data->io->draw_area->style->white_gc,
 382                            TRUE,
 383                            0, 0,
 384                            u_data->io->draw_area->allocation.width,
 385                            u_data->io->draw_area->allocation.height);
 386
 387         distance=5;
 388         /* x_axis */
 389         gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc, LEFT_BORDER+u_data->io->offset,u_data->io->pixmap_height-BOTTOM_BORDER,u_data->io->pixmap_width-RIGHT_BORDER+u_data->io->offset, u_data->io->pixmap_height-BOTTOM_BORDER);
 390         gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,u_data->io->pixmap_width-RIGHT_BORDER+u_data->io->offset, u_data->io->pixmap_height-BOTTOM_BORDER, u_data->io->pixmap_width-RIGHT_BORDER+u_data->io->offset-5, u_data->io->pixmap_height-BOTTOM_BORDER-5);
 391         gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,u_data->io->pixmap_width-RIGHT_BORDER+u_data->io->offset, u_data->io->pixmap_height-BOTTOM_BORDER, u_data->io->pixmap_width-RIGHT_BORDER+u_data->io->offset-5, u_data->io->pixmap_height-BOTTOM_BORDER+5);
 392         u_data->io->axis_width=u_data->io->pixmap_width-LEFT_BORDER-RIGHT_BORDER-u_data->io->offset;
 393
 394         /* try to avoid dividing by zero */
 395         if(u_data->io->tmp_width>0){
 396                 u_data->io->x_interval = (float)((u_data->io->axis_width*1.0)/u_data->io->tmp_width); /*distance in pixels between 2 data points*/
 397         } else {
 398                 u_data->io->x_interval = (float)(u_data->io->axis_width);
 399         }
 400
 401         e=0; /*number of decimals of x_interval*/
 402         if (u_data->io->x_interval<1)
 403         {
 404                 dis=1/u_data->io->x_interval;
 405                 while (dis >1)
 406                 {
 407                         dis/=10;
 408                         e++;
 409                 }
 410                 distance=1;
 411                 for (i=0; i<=e+1; i++)
 412                         distance*=10; /*distance per 100 pixels*/
 413         }
 414         else
 415                 distance=5;
 416
 417         g_snprintf(label_string, 15, "%d", 0);
 418         memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15);
 419         layout = gtk_widget_create_pango_layout(u_data->io->draw_area, label_string);
 420         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 421
 422         if (u_data->io->x1_tmp_usec==0)
 423                 sec=u_data->io->x1_tmp_sec;
 424         else
 425                 sec=u_data->io->x1_tmp_sec+1;
 426
 427
 428         if (u_data->io->offset!=0)
 429         {
 430                 g_snprintf(label_string, 15, "%u", u_data->io->x1_tmp_sec);
 431
 432                 memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15);
 433                 pango_layout_set_text(layout, label_string, -1);
 434                 pango_layout_get_pixel_size(layout, &lwidth, NULL);
 435
 436                 gdk_draw_layout(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,
 437                                 LEFT_BORDER-25,
 438                                 u_data->io->pixmap_height-BOTTOM_BORDER+20,
 439                                 layout);
 440         }
 441
 442         w=(guint32)(500/(guint32)(distance*u_data->io->x_interval)); /*there will be a label for every w_th tic*/
 443
 444         if (w==0)
 445                 w=1;
 446
 447         if (w==4 || w==3 || w==2)
 448         {
 449                 w=5;
 450                 a=distance/10;  /*distance between two tics*/
 451                 b = (guint32)((u_data->io->min_x/100000))%10; /* start for labels*/
 452         }
 453         else
 454         {
 455                 a=distance/5;
 456                 b=0;
 457         }
 458
 459
 460         if (!u_data->io->uoff)
 461         {
 462                 if (a>=1000000)
 463                 {
 464                         start=u_data->io->min_x/1000000*1000000;
 465                         if (a==1000000)
 466                                 b = 0;
 467                 }
 468                 else
 469                 {
 470                         start=u_data->io->min_x/100000;
 471                         if (start%2!=0)
 472                                 start--;
 473                         start*=100000;
 474                         b = (guint32)((start/100000))%10;
 475                 }
 476         }
 477         else
 478         {
 479                 start = u_data->io->min_x;
 480                 if (start%2!=0)
 481                         start--;
 482                 b = 0;
 483
 484         }
 485
 486         for (i=start, j=b; i<=u_data->io->max_x; i+=a, j++)
 487         {
 488                 if (!u_data->io->uoff)
 489                 if (i>=u_data->io->min_x && i%1000000!=0)
 490                 {
 491                         length=5;
 492                         g_snprintf(label_string, 15, "%d", i%1000000);
 493                         if (j%w==0)
 494                         {
 495                                 length=10;
 496                                 memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15);
 497                                 pango_layout_set_text(layout, label_string, -1);
 498                                 pango_layout_get_pixel_size(layout, &lwidth, NULL);
 499                                 gdk_draw_layout(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,
 500                                         (guint32)(LEFT_BORDER+u_data->io->offset+(i-u_data->io->min_x)*u_data->io->x_interval-lwidth/2),
 501                                         u_data->io->pixmap_height-BOTTOM_BORDER+10,
 502                                         layout);
 503                         }
 504                         gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,
 505                                 (guint32)(LEFT_BORDER+u_data->io->offset+(i-u_data->io->min_x)*u_data->io->x_interval),
 506                                 u_data->io->pixmap_height-BOTTOM_BORDER,
 507                                 (guint32)(LEFT_BORDER+u_data->io->offset+(i-u_data->io->min_x)*u_data->io->x_interval),
 508                                 u_data->io->pixmap_height-BOTTOM_BORDER+length);
 509                 }
 510
 511                 if (!u_data->io->uoff)
 512                 {
 513                         if (i%1000000==0 && j%w==0)
 514                         {
 515                                 sec=i/1000000;
 516                                 write_label = TRUE;
 517                         }
 518                 }
 519                 else
 520                 {
 521                         if (j%w == 0)
 522                         {
 523                                 sec = i;
 524                                 write_label = TRUE;
 525                         }
 526                 }
 527                 if (write_label)
 528                 {
 529                         gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,
 530                                       (guint32)(LEFT_BORDER+u_data->io->offset+(i-u_data->io->min_x)*u_data->io->x_interval),
 531                                       u_data->io->pixmap_height-BOTTOM_BORDER,
 532                                       (guint32)(LEFT_BORDER+u_data->io->offset+(i-u_data->io->min_x)*u_data->io->x_interval),
 533                                       u_data->io->pixmap_height-BOTTOM_BORDER+10);
 534
 535                         g_snprintf(label_string, 15, "%d", sec);
 536                         memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15);
 537                         pango_layout_set_text(layout, label_string, -1);
 538                         pango_layout_get_pixel_size(layout, &lwidth, NULL);
 539
 540                         gdk_draw_layout(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,
 541                                         (guint32)(LEFT_BORDER+u_data->io->offset+(i-u_data->io->min_x)*u_data->io->x_interval-10),
 542                                         u_data->io->pixmap_height-BOTTOM_BORDER+20,
 543                                         layout);
 544                         write_label = FALSE;
 545                 }
 546
 547         }
 548
 549         g_strlcpy(label_string, "sec", 15);
 550
 551         memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15);
 552         pango_layout_set_text(layout, label_string, -1);
 553         pango_layout_get_pixel_size(layout, &lwidth, NULL);
 554         gdk_draw_layout(u_data->io->pixmap,
 555                         u_data->io->draw_area->style->black_gc,
 556                         u_data->io->pixmap_width-RIGHT_BORDER-10,
 557                         u_data->io->pixmap_height-BOTTOM_BORDER+30,
 558                         layout);
 559
 560         distance=5;
 561
 562         /* y-axis */
 563         gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc, LEFT_BORDER,TOP_BORDER-u_data->io->offset,LEFT_BORDER,u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset);
 564         gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,LEFT_BORDER,TOP_BORDER-u_data->io->offset, LEFT_BORDER-5, TOP_BORDER-u_data->io->offset+5);
 565         gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,LEFT_BORDER,TOP_BORDER-u_data->io->offset, LEFT_BORDER+5, TOP_BORDER-u_data->io->offset+5);
 566
 567         u_data->io->y_interval = (float)(((u_data->io->pixmap_height-TOP_BORDER-BOTTOM_BORDER)*1.0)/(u_data->io->max_y-u_data->io->min_y));
 568
 569         e=0;
 570         if (u_data->io->y_interval<1)
 571         {
 572                 dis=1/u_data->io->y_interval;
 573                 while (dis >1)
 574                 {
 575                         dis/=10;
 576                         e++;
 577                 }
 578                 distance=1;
 579                 for (i=0; i<=e; i++)
 580                         distance=distance*10;
 581         }
 582         else if (u_data->io->y_interval<2)
 583                 distance = 10;
 584
 585         if (u_data->io->max_y>0)
 586         {
 587                 for (i=u_data->io->min_y/distance*distance; i<=u_data->io->max_y; i+=distance/5)
 588                 {
 589                         if (i>=u_data->io->min_y)
 590                         {
 591                                 length=5;
 592                                 g_snprintf(label_string, 15, "%d", i);
 593                                 if (i%distance==0 || (distance<=5 && u_data->io->y_interval>10))
 594                                 {
 595                                         length=10;
 596
 597                                         memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15);
 598                                         pango_layout_set_text(layout, label_string, -1);
 599                                         pango_layout_get_pixel_size(layout, &lwidth, NULL);
 600                                         gdk_draw_layout(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,
 601                                                         LEFT_BORDER-length-lwidth-5,
 602                                                         (guint32)(u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset-(i-u_data->io->min_y)*u_data->io->y_interval-POINT_SIZE),
 603                                                         layout);
 604                                 }
 605                                 gdk_draw_line(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,LEFT_BORDER-length,
 606                                               (guint32)(u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset-(i-u_data->io->min_y)*u_data->io->y_interval),
 607                                               LEFT_BORDER,
 608                                               (guint32)(u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset-(i-u_data->io->min_y)*u_data->io->y_interval));
 609                         }
 610                 }
 611         }
 612         else if ((u_data->dir==1 && u_data->assoc->n_array_tsn1==0) || (u_data->dir==2 && u_data->assoc->n_array_tsn2==0))
 613                 simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK, "No Data Chunks sent");
 614 }
 615
 616
 617 static void sctp_graph_redraw(struct sctp_udata *u_data)
 618 {
 619 sctp_graph_t *ios;
 620
 621         u_data->io->needs_redraw=TRUE;
 622
 623         sctp_graph_draw(u_data);
 624         switch (u_data->io->graph_type)
 625         {
 626                 case 0:
 627                         draw_sack_graph(u_data);
 628                         draw_tsn_graph(u_data);
 629                         break;
 630                 case 1:
 631                         draw_tsn_graph(u_data);
 632                         break;
 633                 case 2:
 634                         draw_sack_graph(u_data);
 635                         break;
 636         }
 637         ios=(sctp_graph_t *)OBJECT_GET_DATA(u_data->io->draw_area, "sctp_graph_t");
 638
 639         if(!ios){
 640                 exit(10);
 641         }
 642
 643
 644         gdk_draw_pixmap(u_data->io->draw_area->window,
 645                         u_data->io->draw_area->style->fg_gc[GTK_WIDGET_STATE(u_data->io->draw_area)],
 646                         ios->pixmap,
 647                         0,0,
 648                         0, 0,
 649                         u_data->io->draw_area->allocation.width,
 650                         u_data->io->draw_area->allocation.height);
 651 }
 652
 653
 654 static void on_sack_bt(GtkWidget *widget _U_, struct sctp_udata *u_data)
 655 {
 656
 657         u_data = (struct sctp_udata *) u_data;
 658         u_data->io->graph_type=2;
 659         sctp_graph_redraw(u_data);
 660 }
 661
 662 static void on_tsn_bt(GtkWidget *widget _U_, struct sctp_udata *u_data)
 663 {
 664
 665         u_data->io->graph_type=1;
 666         sctp_graph_redraw(u_data);
 667 }
 668
 669 static void on_both_bt(GtkWidget *widget _U_, struct sctp_udata *u_data)
 670 {
 671
 672         u_data->io->graph_type=0;
 673         sctp_graph_redraw(u_data);
 674 }
 675
 676 static void
 677 sctp_graph_close_cb(GtkWidget* widget _U_, gpointer u_data)
 678 {
 679         struct sctp_udata *udata;
 680         int dir;
 681
 682         udata = (struct sctp_udata *)u_data;
 683         dir=udata->dir-1;
 684         gtk_grab_remove(GTK_WIDGET(udata->io->window));
 685         gtk_widget_destroy(GTK_WIDGET(udata->io->window));
 686
 687 }
 688
 689 static gint
 690 configure_event(GtkWidget *widget, GdkEventConfigure *event _U_, struct sctp_udata *u_data)
 691 {
 692         if(!u_data->io){
 693                 exit(10);
 694         }
 695
 696         if(u_data->io->pixmap){
 697                 gdk_pixmap_unref(u_data->io->pixmap);
 698                 u_data->io->pixmap=NULL;
 699         }
 700
 701         u_data->io->pixmap=gdk_pixmap_new(widget->window,
 702                         widget->allocation.width,
 703                         widget->allocation.height,
 704                         -1);
 705         u_data->io->pixmap_width=widget->allocation.width;
 706         u_data->io->pixmap_height=widget->allocation.height;
 707
 708         gdk_draw_rectangle(u_data->io->pixmap,
 709                         widget->style->white_gc,
 710                         TRUE,
 711                         0, 0,
 712                         widget->allocation.width,
 713                         widget->allocation.height);
 714         sctp_graph_redraw(u_data);
 715         return TRUE;
 716 }
 717
 718 static gint
 719 expose_event(GtkWidget *widget, GdkEventExpose *event)
 720 {
 721         sctp_graph_t *ios;
 722
 723         ios=(sctp_graph_t *)OBJECT_GET_DATA(widget, "sctp_graph_t");
 724         if(!ios){
 725                 exit(10);
 726         }
 727
 728         gdk_draw_pixmap(widget->window,
 729                         widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 730                         ios->pixmap,
 731                         event->area.x, event->area.y,
 732                         event->area.x, event->area.y,
 733                         event->area.width, event->area.height);
 734
 735         return FALSE;
 736 }
 737
 738
 739 static void
 740 on_zoomin_bt (GtkWidget *widget _U_, struct sctp_udata *u_data)
 741 {
 742         sctp_min_max_t *tmp_minmax;
 743
 744         if (u_data->io->rectangle_present==TRUE)
 745         {
 746                 tmp_minmax = g_malloc(sizeof(sctp_min_max_t));
 747
 748                 u_data->io->tmp_min_tsn1=u_data->io->y1_tmp+u_data->io->min_y;
 749                 u_data->io->tmp_max_tsn1=u_data->io->y2_tmp+1+u_data->io->min_y;
 750                 u_data->io->tmp_min_tsn2=u_data->io->tmp_min_tsn1;
 751                 u_data->io->tmp_max_tsn2=u_data->io->tmp_max_tsn1;
 752                 tmp_minmax->tmp_min_secs=u_data->io->x1_tmp_sec;
 753                 tmp_minmax->tmp_min_usecs=      u_data->io->x1_tmp_usec;
 754                 tmp_minmax->tmp_max_secs=       u_data->io->x2_tmp_sec;
 755                 tmp_minmax->tmp_max_usecs=      u_data->io->x2_tmp_usec;
 756                 tmp_minmax->tmp_min_tsn1=u_data->io->tmp_min_tsn1;
 757                 tmp_minmax->tmp_max_tsn1=u_data->io->tmp_max_tsn1;
 758                 tmp_minmax->tmp_min_tsn2=u_data->io->tmp_min_tsn2;
 759                 tmp_minmax->tmp_max_tsn2=u_data->io->tmp_max_tsn2;
 760                 u_data->assoc->min_max = g_slist_prepend(u_data->assoc->min_max, tmp_minmax);
 761                 u_data->io->length = g_slist_length(u_data->assoc->min_max);
 762                 u_data->io->tmp=TRUE;
 763                 u_data->io->rectangle=FALSE;
 764                 u_data->io->rectangle_present=FALSE;
 765                 gtk_widget_set_sensitive(zoomout_bt, TRUE);
 766                 sctp_graph_redraw(u_data);
 767         }
 768         else
 769         {
 770                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK, "Please draw a rectangle around the area you want to zoom in!");
 771         }
 772 }
 773
 774 static void
 775 zoomin_bt (struct sctp_udata *u_data)
 776 {
 777         sctp_min_max_t *tmp_minmax;
 778
 779         tmp_minmax = g_malloc(sizeof(sctp_min_max_t));
 780
 781         u_data->io->tmp_min_tsn1=u_data->io->y1_tmp+u_data->io->min_y;
 782         u_data->io->tmp_max_tsn1=u_data->io->y2_tmp+1+u_data->io->min_y;
 783         u_data->io->tmp_min_tsn2=u_data->io->tmp_min_tsn1;
 784         u_data->io->tmp_max_tsn2=u_data->io->tmp_max_tsn1;
 785         tmp_minmax->tmp_min_secs=u_data->io->x1_tmp_sec;
 786         tmp_minmax->tmp_min_usecs=      u_data->io->x1_tmp_usec;
 787         tmp_minmax->tmp_max_secs=       u_data->io->x2_tmp_sec;
 788         tmp_minmax->tmp_max_usecs=      u_data->io->x2_tmp_usec;
 789         tmp_minmax->tmp_min_tsn1=u_data->io->tmp_min_tsn1;
 790         tmp_minmax->tmp_max_tsn1=u_data->io->tmp_max_tsn1;
 791         tmp_minmax->tmp_min_tsn2=u_data->io->tmp_min_tsn2;
 792         tmp_minmax->tmp_max_tsn2=u_data->io->tmp_max_tsn2;
 793         u_data->assoc->min_max = g_slist_prepend(u_data->assoc->min_max, tmp_minmax);
 794         u_data->io->length = g_slist_length(u_data->assoc->min_max);
 795         u_data->io->tmp=TRUE;
 796         u_data->io->rectangle=FALSE;
 797         u_data->io->rectangle_present=FALSE;
 798         gtk_widget_set_sensitive(zoomout_bt, TRUE);
 799         sctp_graph_redraw(u_data);
 800
 801 }
 802
 803
 804
 805 static void
 806 on_zoomout_bt (GtkWidget *widget _U_, struct sctp_udata *u_data)
 807 {
 808         sctp_min_max_t *tmp_minmax, *mm;
 809         gint l;
 810
 811         l = g_slist_length(u_data->assoc->min_max);
 812
 813         if (u_data->assoc->min_max!=NULL)
 814         {
 815                 mm=(sctp_min_max_t *)((u_data->assoc->min_max)->data);
 816                 u_data->assoc->min_max=g_slist_remove(u_data->assoc->min_max, mm);
 817                 g_free(mm);
 818                 if (l>2)
 819                 {
 820                         tmp_minmax = (sctp_min_max_t *)u_data->assoc->min_max->data;
 821                         u_data->io->x1_tmp_sec=tmp_minmax->tmp_min_secs;
 822                         u_data->io->x1_tmp_usec=tmp_minmax->tmp_min_usecs;
 823                         u_data->io->x2_tmp_sec=tmp_minmax->tmp_max_secs;
 824                         u_data->io->x2_tmp_usec=tmp_minmax->tmp_max_usecs;
 825                         u_data->io->tmp_min_tsn1=tmp_minmax->tmp_min_tsn1;
 826                         u_data->io->tmp_max_tsn1=tmp_minmax->tmp_max_tsn1;
 827                         u_data->io->tmp_min_tsn2=tmp_minmax->tmp_min_tsn2;
 828                         u_data->io->tmp_max_tsn2=tmp_minmax->tmp_max_tsn2;
 829                         u_data->io->tmp=TRUE;
 830                 }
 831                 else
 832                 {
 833                         u_data->io->x1_tmp_sec=u_data->assoc->min_secs;
 834                         u_data->io->x1_tmp_usec=u_data->assoc->min_usecs;
 835                         u_data->io->x2_tmp_sec=u_data->assoc->max_secs;
 836                         u_data->io->x2_tmp_usec=u_data->assoc->max_usecs;
 837                         u_data->io->tmp_min_tsn1=u_data->assoc->min_tsn1;
 838                         u_data->io->tmp_max_tsn1=u_data->assoc->max_tsn1;
 839                         u_data->io->tmp_min_tsn2=u_data->assoc->min_tsn2;
 840                         u_data->io->tmp_max_tsn2=u_data->assoc->max_tsn2;
 841                         u_data->io->tmp=FALSE;
 842                 }
 843         }
 844         else
 845         {
 846                 u_data->io->x1_tmp_sec=u_data->assoc->min_secs;
 847                 u_data->io->x1_tmp_usec=u_data->assoc->min_usecs;
 848                 u_data->io->x2_tmp_sec=u_data->assoc->max_secs;
 849                 u_data->io->x2_tmp_usec=u_data->assoc->max_usecs;
 850                 u_data->io->tmp_min_tsn1=u_data->assoc->min_tsn1;
 851                 u_data->io->tmp_max_tsn1=u_data->assoc->max_tsn1;
 852                 u_data->io->tmp_min_tsn2=u_data->assoc->min_tsn2;
 853                 u_data->io->tmp_max_tsn2=u_data->assoc->max_tsn2;
 854                 u_data->io->tmp=FALSE;
 855         }
 856         if (g_slist_length(u_data->assoc->min_max)==1)
 857                 gtk_widget_set_sensitive(zoomout_bt, FALSE);
 858         sctp_graph_redraw(u_data);
 859 }
 860
 861 static gint
 862 on_button_press (GtkWidget *widget _U_, GdkEventButton *event, struct sctp_udata *u_data)
 863 {
 864         sctp_graph_t *ios;
 865
 866         if (u_data->io->rectangle==TRUE)
 867         {
 868                 gdk_draw_rectangle(u_data->io->pixmap,u_data->io->draw_area->style->white_gc,
 869                                    FALSE,
 870                                    (gint)floor(MIN(u_data->io->x_old,u_data->io->x_new)),
 871                                    (gint)floor(MIN(u_data->io->y_old,u_data->io->y_new)),
 872                                    (gint)floor(abs((long)(u_data->io->x_new-u_data->io->x_old))),
 873                                    (gint)floor(abs((long)(u_data->io->y_new-u_data->io->y_old))));
 874                 ios=(sctp_graph_t *)OBJECT_GET_DATA(u_data->io->draw_area, "sctp_graph_t");
 875
 876                 if(!ios){
 877                         exit(10);
 878                 }
 879
 880                 gdk_draw_pixmap(u_data->io->draw_area->window,
 881                                 u_data->io->draw_area->style->fg_gc[GTK_WIDGET_STATE(u_data->io->draw_area)],
 882                                 ios->pixmap,
 883                                 0,0,
 884                                 0, 0,
 885                                 (gint)(abs((long)(u_data->io->x_new-u_data->io->x_old))),
 886                                 (gint)(abs((long)(u_data->io->y_new-u_data->io->y_old))));
 887                 sctp_graph_redraw(u_data);
 888         }
 889         u_data->io->x_old=event->x;
 890         u_data->io->y_old=event->y;
 891         if (u_data->io->y_old>u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset-POINT_SIZE)
 892                 u_data->io->y_old=u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset-POINT_SIZE;
 893         if (u_data->io->x_old<LEFT_BORDER+u_data->io->offset)
 894                 u_data->io->x_old=LEFT_BORDER+u_data->io->offset;
 895         u_data->io->rectangle=FALSE;
 896
 897         return TRUE;
 898 }
 899
 900
 901 static gint
 902 on_button_release (GtkWidget *widget _U_, GdkEventButton *event, struct sctp_udata *u_data)
 903 {
 904         sctp_graph_t *ios;
 905         guint32 helpx, helpy, x1_tmp, x2_tmp,  y_value, t_size=0, s_size=0, i, y_tolerance;
 906         gint label_width, label_height;
 907         gdouble x_value, position, s_diff=0, t_diff=0, x_tolerance=0.0001;
 908         gint lwidth;
 909         char label_string[30];
 910         GdkGC *text_color;
 911         GPtrArray *tsnlist = NULL, *sacklist=NULL;
 912         struct tsn_sort *tsn, *sack=NULL;
 913         gboolean sack_found = FALSE;
 914         PangoLayout  *layout;
 915
 916         g_snprintf(label_string, 15, "%d", 0);
 917         memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15);
 918         layout = gtk_widget_create_pango_layout(u_data->io->draw_area, label_string);
 919         pango_layout_get_pixel_size(layout, &label_width, &label_height);
 920
 921         if (event->y>u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset)
 922                 event->y = u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset;
 923         if (event->x < LEFT_BORDER+u_data->io->offset)
 924                 event->x = LEFT_BORDER+u_data->io->offset;
 925         if (abs((long)(event->x-u_data->io->x_old))>10 || abs((long)(event->y-u_data->io->y_old))>10)
 926         {
 927                 u_data->io->rect_x_min = (gint)floor(MIN(u_data->io->x_old,event->x));
 928                 u_data->io->rect_x_max = (gint)ceil(MAX(u_data->io->x_old,event->x));
 929                 u_data->io->rect_y_min = (gint)floor(MIN(u_data->io->y_old,event->y));
 930                 u_data->io->rect_y_max = (gint)ceil(MAX(u_data->io->y_old,event->y))+POINT_SIZE;
 931                 gdk_draw_rectangle(u_data->io->pixmap,u_data->io->draw_area->style->black_gc,
 932                                    FALSE,
 933                                    u_data->io->rect_x_min, u_data->io->rect_y_min,
 934                                    u_data->io->rect_x_max - u_data->io->rect_x_min,
 935                                    u_data->io->rect_y_max - u_data->io->rect_y_min);
 936                 ios=(sctp_graph_t *)OBJECT_GET_DATA(u_data->io->draw_area, "sctp_graph_t");
 937
 938                 if(!ios){
 939                         exit(10);
 940                 }
 941
 942                 gdk_draw_pixmap(u_data->io->draw_area->window,
 943                                 u_data->io->draw_area->style->fg_gc[GTK_WIDGET_STATE(u_data->io->draw_area)],
 944                                 ios->pixmap,
 945                                 0, 0,
 946                                 0, 0,
 947                                 u_data->io->draw_area->allocation.width,
 948                                 u_data->io->draw_area->allocation.height);
 949
 950                 x1_tmp=(unsigned int)floor(u_data->io->min_x+((u_data->io->x_old-LEFT_BORDER-u_data->io->offset)*u_data->io->tmp_width/u_data->io->axis_width));
 951                 x2_tmp=(unsigned int)floor(u_data->io->min_x+((event->x-LEFT_BORDER-u_data->io->offset)*u_data->io->tmp_width/u_data->io->axis_width));
 952                 helpx=MIN(x1_tmp, x2_tmp);
 953                 if (helpx==x2_tmp)
 954                 {
 955                         x2_tmp=x1_tmp;
 956                         x1_tmp=helpx;
 957                 }
 958                 if (u_data->io->uoff)
 959                 {
 960                         if (x2_tmp - x1_tmp <= 1500)
 961                                 u_data->io->uoff = FALSE;
 962                         u_data->io->x1_tmp_sec=(guint32)x1_tmp;
 963                         u_data->io->x1_tmp_usec=0;
 964                         u_data->io->x2_tmp_sec=(guint32)x2_tmp;
 965                         u_data->io->x2_tmp_usec=0;
 966                 }
 967                 else
 968                 {
 969                         u_data->io->x1_tmp_sec=(guint32)x1_tmp/1000000;
 970                         u_data->io->x1_tmp_usec=x1_tmp%1000000;
 971                         u_data->io->x2_tmp_sec=(guint32)x2_tmp/1000000;
 972                         u_data->io->x2_tmp_usec=x2_tmp%1000000;
 973                 }
 974                 u_data->io->x1_akt_sec = u_data->io->x1_tmp_sec;
 975                 u_data->io->x1_akt_usec = u_data->io->x1_tmp_usec;
 976                 u_data->io->x2_akt_sec = u_data->io->x2_tmp_sec;
 977                 u_data->io->x2_akt_usec = u_data->io->x2_tmp_usec;
 978
 979                 u_data->io->y1_tmp=(guint32)((u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset-u_data->io->y_old)/u_data->io->y_interval);
 980                 u_data->io->y2_tmp=(guint32)((u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset-event->y)/u_data->io->y_interval);
 981                 helpy = MIN(u_data->io->y1_tmp, u_data->io->y2_tmp);
 982                 u_data->io->y2_tmp = MAX(u_data->io->y1_tmp, u_data->io->y2_tmp);
 983                 u_data->io->y1_tmp = helpy;
 984                 u_data->io->x_new=event->x;
 985                 u_data->io->y_new=event->y;
 986                 u_data->io->rectangle=TRUE;
 987                 u_data->io->rectangle_present=TRUE;
 988         }
 989         else
 990         {
 991                 if (u_data->io->rectangle_present==TRUE)
 992                 {
 993                         u_data->io->rectangle_present=FALSE;
 994                         if (event->x >= u_data->io->rect_x_min && event->x <= u_data->io->rect_x_max &&
 995                              event->y >= u_data->io->rect_y_min && event->y <= u_data->io->rect_y_max)
 996                                 zoomin_bt(u_data);
 997                         else
 998                         {
 999                                 u_data->io->x1_tmp_sec = u_data->io->x1_akt_sec;
1000                                 u_data->io->x1_tmp_usec = u_data->io->x1_akt_usec;
1001                                 u_data->io->x2_tmp_sec = u_data->io->x2_akt_sec;
1002                                 u_data->io->x2_tmp_usec = u_data->io->x2_akt_usec;
1003                                 sctp_graph_redraw(u_data);
1004                         }
1005                 }
1006                 else if (label_set)
1007                 {
1008                         label_set = FALSE;
1009                         sctp_graph_redraw(u_data);
1010                 }
1011                 else
1012                 {
1013                         x_value = ((event->x-LEFT_BORDER-u_data->io->offset) * ((u_data->io->x2_tmp_sec+u_data->io->x2_tmp_usec/1000000.0)-(u_data->io->x1_tmp_sec+u_data->io->x1_tmp_usec/1000000.0)) / (u_data->io->pixmap_width-LEFT_BORDER-RIGHT_BORDER-u_data->io->offset))+u_data->io->x1_tmp_sec+u_data->io->x1_tmp_usec/1000000.0;
1014                         y_value = (gint)rint((u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset-event->y) * (max_tsn - min_tsn) / (u_data->io->pixmap_height-BOTTOM_BORDER-u_data->io->offset)) + min_tsn;
1015                         text_color = u_data->io->draw_area->style->black_gc;
1016
1017                         if (u_data->dir == 1)
1018                         {
1019                                 tsnlist = u_data->assoc->sort_tsn1;
1020                                 t_size = u_data->assoc->n_data_chunks_ep1;
1021                                 sacklist = u_data->assoc->sort_sack1;
1022                                 s_size = u_data->assoc->n_sack_chunks_ep1;
1023                         }
1024                         else
1025                         {
1026                                 tsnlist = u_data->assoc->sort_tsn2;
1027                                 t_size = u_data->assoc->n_data_chunks_ep2;
1028                                 sacklist = u_data->assoc->sort_sack2;
1029                                 s_size = u_data->assoc->n_sack_chunks_ep2;
1030                         }
1031                         x_tolerance = (gdouble)((u_data->io->tmp_width / u_data->io->axis_width*1.0))*5/1000000.0;
1032                         y_tolerance = (guint32)(((u_data->io->max_y - u_data->io->min_y) / (u_data->io->pixmap_height-TOP_BORDER-BOTTOM_BORDER-u_data->io->offset)) * 2.0);
1033                         if (y_tolerance==0)
1034                                 y_tolerance = 2;
1035                         else if (y_tolerance > 5)
1036                                 y_tolerance = 5;
1037
1038                         for (i=0; i<s_size; i++)
1039                         {
1040                                 sack = (struct tsn_sort*)(g_ptr_array_index(sacklist, i));
1041                                 if ((guint32)abs(sack->tsnumber - y_value)<y_tolerance)
1042                                 {
1043                                         s_diff = fabs((sack->secs+sack->usecs/1000000.0)- x_value);
1044                                         if (s_diff < x_tolerance)
1045                                                 sack_found = TRUE;
1046                                         break;
1047                                 }
1048                         }
1049
1050                         for (i=0; i<t_size; i++)
1051                         {
1052                                 tsn = (struct tsn_sort*)(g_ptr_array_index(tsnlist, i));
1053                                 if ((guint32)abs(tsn->tsnumber - y_value)<y_tolerance)
1054                                 {
1055                                         t_diff = fabs((tsn->secs+tsn->usecs/1000000.0)- x_value);
1056                                         if (sack_found && s_diff < t_diff)
1057                                         {
1058                                                 cf_goto_frame(&cfile, sack->framenumber);
1059                                                 x_value = sack->secs+sack->usecs/1000000.0;
1060                                                 y_value = sack->tsnumber;
1061                                         }
1062                                         else if (t_diff < x_tolerance)
1063                                         {
1064                                                 cf_goto_frame(&cfile, tsn->framenumber);
1065                                                 x_value = tsn->secs+tsn->usecs/1000000.0;
1066                                                 y_value = tsn->tsnumber;
1067                                         }
1068                                         break;
1069                                 }
1070                         }
1071
1072                         g_snprintf(label_string, 30, "(%.6lf, %u)", x_value, y_value);
1073
1074                         label_set = TRUE;
1075
1076                         gdk_draw_line(u_data->io->pixmap,text_color, (gint)(event->x-2), (gint)(event->y), (gint)(event->x+2), (gint)(event->y));
1077                         gdk_draw_line(u_data->io->pixmap,text_color, (gint)(event->x), (gint)(event->y-2), (gint)(event->x), (gint)(event->y+2));
1078                         if (event->x+150>=u_data->io->pixmap_width)
1079                                 position = event->x - 150;
1080                         else
1081                                 position = event->x + 5;
1082
1083
1084                         memcpy(label_string,(gchar *)g_locale_to_utf8(label_string, -1 , NULL, NULL, NULL), 15);
1085                         pango_layout_set_text(layout, label_string, -1);
1086                         pango_layout_get_pixel_size(layout, &lwidth, NULL);
1087
1088                         gdk_draw_layout(u_data->io->pixmap,text_color,
1089                                         (gint)position,
1090                                         (gint)(event->y-10),
1091                                         layout);
1092
1093                         ios=(sctp_graph_t *)OBJECT_GET_DATA(u_data->io->draw_area, "sctp_graph_t");
1094
1095                         if(!ios){
1096                                 exit(10);
1097                         }
1098                         gdk_draw_pixmap(u_data->io->draw_area->window,
1099                                         u_data->io->draw_area->style->fg_gc[GTK_WIDGET_STATE(u_data->io->draw_area)],
1100                                         ios->pixmap,
1101                                         0, 0,
1102                                         0, 0,
1103                                         u_data->io->draw_area->allocation.width,
1104                                         u_data->io->draw_area->allocation.height);
1105                 }
1106         }
1107         return TRUE;
1108 }
1109
1110
1111 static void init_sctp_graph_window(struct sctp_udata *u_data)
1112 {
1113         GtkWidget *vbox;
1114         GtkWidget *hbox;
1115         GtkWidget *bt_close, *sack_bt, *tsn_bt, *both_bt, *zoomin_bt;
1116         GtkTooltips *tooltip_in, *tooltip_out;
1117
1118         /* create the main window */
1119
1120         u_data->io->window=gtk_window_new(GTK_WINDOW_TOPLEVEL);
1121
1122         gtk_widget_set_name(u_data->io->window, "SCTP Graphics");
1123
1124         vbox=gtk_vbox_new(FALSE, 0);
1125         gtk_container_add(GTK_CONTAINER(u_data->io->window), vbox);
1126         gtk_widget_show(vbox);
1127
1128         create_draw_area(vbox, u_data);
1129
1130         sctp_graph_set_title(u_data);
1131
1132         hbox = gtk_hbutton_box_new();
1133         gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
1134         gtk_container_set_border_width(GTK_CONTAINER(hbox), 10);
1135         gtk_button_box_set_layout(GTK_BUTTON_BOX (hbox), GTK_BUTTONBOX_SPREAD);
1136         gtk_button_box_set_spacing(GTK_BUTTON_BOX (hbox), 0);
1137         gtk_box_set_child_packing(GTK_BOX(vbox), hbox, FALSE, FALSE, 0, GTK_PACK_START);
1138         gtk_widget_show(hbox);
1139
1140         sack_bt = gtk_button_new_with_label ("Show Sacks");
1141         gtk_box_pack_start(GTK_BOX(hbox), sack_bt, FALSE, FALSE, 0);
1142         gtk_widget_show(sack_bt);
1143
1144         gtk_signal_connect(GTK_OBJECT(sack_bt), "clicked", (GtkSignalFunc)on_sack_bt, u_data);
1145
1146         tsn_bt = gtk_button_new_with_label ("Show TSNs");
1147         gtk_box_pack_start(GTK_BOX(hbox), tsn_bt, FALSE, FALSE, 0);
1148         gtk_widget_show(tsn_bt);
1149         SIGNAL_CONNECT(tsn_bt, "clicked", on_tsn_bt, u_data);
1150
1151         both_bt = gtk_button_new_with_label ("Show both");
1152         gtk_box_pack_start(GTK_BOX(hbox), both_bt, FALSE, FALSE, 0);
1153         gtk_widget_show(both_bt);
1154         SIGNAL_CONNECT(both_bt, "clicked", on_both_bt, u_data);
1155
1156         zoomin_bt = gtk_button_new_with_label ("Zoom in");
1157         gtk_box_pack_start(GTK_BOX(hbox), zoomin_bt, FALSE, FALSE, 0);
1158         gtk_widget_show(zoomin_bt);
1159         SIGNAL_CONNECT(zoomin_bt, "clicked", on_zoomin_bt, u_data);
1160         tooltip_in = gtk_tooltips_new();
1161         gtk_tooltips_set_tip(tooltip_in, zoomin_bt, "Zoom in the area you have selected", NULL);
1162
1163         zoomout_bt = gtk_button_new_with_label ("Zoom out");
1164         gtk_box_pack_start(GTK_BOX(hbox), zoomout_bt, FALSE, FALSE, 0);
1165         gtk_widget_show(zoomout_bt);
1166         SIGNAL_CONNECT(zoomout_bt, "clicked", on_zoomout_bt, u_data);
1167         tooltip_out = gtk_tooltips_new();
1168         gtk_tooltips_set_tip(tooltip_out, zoomout_bt, "Zoom out one step", NULL);
1169         gtk_widget_set_sensitive(zoomout_bt, FALSE);
1170
1171         bt_close = BUTTON_NEW_FROM_STOCK(GTK_STOCK_CLOSE);
1172         gtk_box_pack_start(GTK_BOX(hbox), bt_close, FALSE, FALSE, 0);
1173         gtk_widget_show(bt_close);
1174         SIGNAL_CONNECT(bt_close, "clicked", sctp_graph_close_cb, u_data);
1175
1176         gtk_signal_connect(GTK_OBJECT(u_data->io->draw_area),"button_press_event",(GtkSignalFunc)on_button_press, u_data);
1177         gtk_signal_connect(GTK_OBJECT(u_data->io->draw_area),"button_release_event",(GtkSignalFunc)on_button_release, u_data);
1178         gtk_widget_set_events(u_data->io->draw_area, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_EXPOSURE_MASK);
1179
1180         gtk_widget_show(u_data->io->window);
1181 }
1182
1183 static void sctp_graph_set_title(struct sctp_udata *u_data)
1184 {
1185         char *title;
1186
1187         if(!u_data->io->window)
1188         {
1189                 return;
1190         }
1191         title = g_strdup_printf("SCTP TSNs and Sacks over Time: %s Port1 %u Port2 %u Endpoint %u",
1192                                 cf_get_display_name(&cfile), u_data->parent->assoc->port1, u_data->parent->assoc->port2, u_data->dir);
1193         gtk_window_set_title(GTK_WINDOW(u_data->io->window), title);
1194         g_free(title);
1195 }
1196
1197 static void
1198 gtk_sctpgraph_init(struct sctp_udata *u_data)
1199 {
1200         sctp_graph_t *io;
1201         gint dir;
1202         sctp_min_max_t* tmp_minmax;
1203
1204         io=g_malloc(sizeof(sctp_graph_t));
1205         io->needs_redraw=TRUE;
1206         io->x_interval=1000;
1207         io->window=NULL;
1208         io->draw_area=NULL;
1209         io->pixmap=NULL;
1210         io->pixmap_width=800;
1211         io->pixmap_height=600;
1212         io->graph_type=0;
1213         dir=u_data->dir-1;
1214         u_data->io=io;
1215         u_data->io->x1_tmp_sec=u_data->assoc->min_secs;
1216         u_data->io->x1_tmp_usec=u_data->assoc->min_usecs;
1217         u_data->io->x2_tmp_sec=u_data->assoc->max_secs;
1218         u_data->io->x2_tmp_usec=u_data->assoc->max_usecs;
1219         u_data->io->tmp_min_tsn1=u_data->assoc->min_tsn1;
1220         u_data->io->tmp_max_tsn1=u_data->assoc->max_tsn1;
1221         u_data->io->tmp_min_tsn2=u_data->assoc->min_tsn2;
1222         u_data->io->tmp_max_tsn2=u_data->assoc->max_tsn2;
1223         u_data->io->tmp=FALSE;
1224
1225         tmp_minmax = g_malloc(sizeof(sctp_min_max_t));
1226         tmp_minmax->tmp_min_secs = u_data->assoc->min_secs;
1227         tmp_minmax->tmp_min_usecs=u_data->assoc->min_usecs;
1228         tmp_minmax->tmp_max_secs=u_data->assoc->max_secs;
1229         tmp_minmax->tmp_max_usecs=u_data->assoc->max_usecs;
1230         tmp_minmax->tmp_min_tsn2=u_data->assoc->min_tsn2;
1231         tmp_minmax->tmp_min_tsn1=u_data->assoc->min_tsn1;
1232         tmp_minmax->tmp_max_tsn1=u_data->assoc->max_tsn1;
1233         tmp_minmax->tmp_max_tsn2=u_data->assoc->max_tsn2;
1234         u_data->assoc->min_max = g_slist_prepend(u_data->assoc->min_max, tmp_minmax);
1235
1236         /* build the GUI */
1237         init_sctp_graph_window(u_data);
1238         sctp_graph_redraw(u_data);
1239
1240 }
1241
1242
1243 static gint
1244 quit(GtkObject *object _U_, gpointer user_data)
1245 {
1246         struct sctp_udata *u_data=(struct sctp_udata*)user_data;
1247
1248         decrease_childcount(u_data->parent);
1249         remove_child(u_data, u_data->parent);
1250
1251         g_free(u_data->io);
1252
1253         u_data->assoc->min_max = NULL;
1254         g_free(u_data);
1255         return TRUE;
1256 }
1257
1258
1259 static void create_draw_area(GtkWidget *box, struct sctp_udata *u_data)
1260 {
1261
1262         u_data->io->draw_area=gtk_drawing_area_new();
1263         SIGNAL_CONNECT(u_data->io->draw_area, "destroy", quit, u_data);
1264         OBJECT_SET_DATA(u_data->io->draw_area, "sctp_graph_t", u_data->io);
1265
1266         WIDGET_SET_SIZE(u_data->io->draw_area, u_data->io->pixmap_width, u_data->io->pixmap_height);
1267
1268         /* signals needed to handle backing pixmap */
1269         SIGNAL_CONNECT(u_data->io->draw_area, "expose_event", expose_event, NULL);
1270         SIGNAL_CONNECT(u_data->io->draw_area, "configure_event", configure_event, u_data);
1271
1272         gtk_widget_show(u_data->io->draw_area);
1273         gtk_box_pack_start(GTK_BOX(box), u_data->io->draw_area, TRUE, TRUE, 0);
1274 }
1275
1276
1277
1278 void create_graph(guint16 dir, struct sctp_analyse* userdata)
1279 {
1280         struct sctp_udata *u_data;
1281
1282         u_data=g_malloc(sizeof(struct sctp_udata));
1283         u_data->assoc=g_malloc(sizeof(sctp_assoc_info_t));
1284         u_data->assoc=userdata->assoc;
1285         u_data->io=NULL;
1286         u_data->dir = dir;
1287         u_data->parent = userdata;
1288         if ((u_data->dir==1 && u_data->assoc->n_array_tsn1==0)|| (u_data->dir==2 && u_data->assoc->n_array_tsn2==0))
1289                 simple_dialog(ESD_TYPE_INFO, ESD_BTN_OK, "No Data Chunks sent");
1290         else
1291         {
1292                 set_child(u_data, u_data->parent);
1293                 increase_childcount(u_data->parent);
1294                 gtk_sctpgraph_init(u_data);
1295         }
1296 }
1297
1298 #if defined(_WIN32) && !defined(__MINGW32__)
1299 /* replacement of Unix rint() for Windows */
1300 static int rint (double x)
1301 {
1302         char *buf;
1303         int i,dec,sig;
1304
1305         buf = _fcvt(x, 0, &dec, &sig);
1306         i = atoi(buf);
1307         if(sig == 1) {
1308                 i = i * -1;
1309         }
1310         return(i);
1311 }
1312 #endif