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