Redesigned the menu structure of the former statistics stuff,
[obnox/wireshark/wip.git] / gtk / tcp_graph.c
1 /* tcp_graph.c
2  * TCP graph drawing code
3  * By Pavel Mores <pvl@uh.cz>
4  * Win32 port:  rwh@unifiedtech.com
5  *
6  * $Id: tcp_graph.c,v 1.52 2004/02/22 18:44:03 ulfl Exp $
7  *
8  * Ethereal - Network traffic analyzer
9  * By Gerald Combs <gerald@ethereal.com>
10  * Copyright 1998 Gerald Combs
11  *
12  * This program is free software; you can redistribute it and/or
13  * modify it under the terms of the GNU General Public License
14  * as published by the Free Software Foundation; either version 2
15  * of the License, or (at your option) any later version.
16  *
17  * This program is distributed in the hope that it will be useful,
18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20  * GNU General Public License for more details.
21  *
22  * You should have received a copy of the GNU General Public License
23  * along with this program; if not, write to the Free Software
24  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
25  */
26
27 #ifdef HAVE_CONFIG_H
28 # include "config.h"
29 #endif
30
31 #include <gtk/gtk.h>
32 #include <gdk/gdkkeysyms.h>
33 #include <math.h>               /* rint() */
34 #include <string.h>
35
36 #ifdef NEED_SNPRINTF_H
37 # include "snprintf.h"
38 #endif
39
40 #include "ipproto.h"
41 #include "globals.h"            /* cfile */
42 #include <epan/packet.h>        /* frame_data */
43 #include "gtkglobals.h"         /* packet_list */
44 #include "simple_dialog.h"
45 #include "ui_util.h"
46 #include "color.h"
47 #include "tcp_graph.h"
48 #include "compat_macros.h"
49 #include "etypes.h"
50 #include "ppptypes.h"
51 #include "dlg_utils.h"
52 #include <epan/epan_dissect.h>
53 #include "tap_menu.h"
54
55 /* from <net/ethernet.h> */
56 struct ether_header {
57         guint8 ether_dhost[6];  /* destination eth addr */
58         guint8 ether_shost[6];  /* source ether addr */
59         guint16 ether_type;     /* packet type ID field */
60 };
61
62 /* reverse engineered from capture file, not too difficult :) */
63 struct ppp_header {
64         guint8 ppp_type;        /* Protocol on PPP connection */
65 };
66
67 /* 802.1q header */
68 struct vlan_802_1_q {
69         guint16 info;
70         guint16 type;
71 };
72
73 /* from <netinet/ip.h> */
74 struct iphdr {
75         guint8 version_ihl;
76         guint8 tos;
77         guint16 tot_len;
78         guint16 id;
79         guint16 frag_off;
80         guint8 ttl;
81         guint8 protocol;
82         guint16 check;
83         guint32 saddr;
84         guint32 daddr;
85 };
86
87 #define IPHDR_IHL_SHIFT         0
88 #define IPHDR_IHL_MASK          (0xf << IPHDR_IHL_SHIFT)
89 #define IHL(iphdrptr)           ( ((iphdrptr)->version_ihl & IPHDR_IHL_MASK) >> IPHDR_IHL_SHIFT )
90
91 /* from <netinet/tcp.h> */
92 struct tcphdr {
93         guint16 source;
94         guint16 dest;
95         guint32 seq;
96         guint32 ack_seq;
97         guint16 flags;
98 #define TH_FIN    0x01
99 #define TH_SYN    0x02
100 #define TH_RST    0x04
101 #define TH_PUSH   0x08
102 #define TH_ACK    0x10
103 #define TH_URG    0x20
104         guint16 window;
105         guint16 check;
106         guint16 urg_ptr;
107 };
108
109 #define TCP_SYN(tcphdr)         ( g_ntohs ((tcphdr).flags) & TH_SYN )
110 #define TCP_ACK(tcphdr)         ( g_ntohs ((tcphdr).flags) & TH_ACK )
111 #define TCP_DOFF_SHIFT          12
112 #define TCP_DOFF_MASK           (0xf << TCP_DOFF_SHIFT)
113 #define DOFF(tcphdr)            ( ( g_ntohs ((tcphdr).flags) & TCP_DOFF_MASK) >> TCP_DOFF_SHIFT )
114
115 #define TXT_WIDTH       850
116 #define TXT_HEIGHT      550
117
118 /* for compare_headers() */
119 /* segment went the same direction as the currently selected one */
120 #define COMPARE_CURR_DIR        0
121 #define COMPARE_ANY_DIR         1
122
123 /* initalize_axis() */
124 #define AXIS_HORIZONTAL         0
125 #define AXIS_VERTICAL           1
126
127 struct segment {
128         struct segment *next;
129         guint32 num;
130         guint32 rel_secs;
131         guint32 rel_usecs;
132         guint32 abs_secs;
133         guint32 abs_usecs;
134         struct iphdr iphdr;
135         struct tcphdr tcphdr;
136         int data;                               /* amount of data in this segment */
137 };
138
139 struct rect {
140         double x, y, width, height;
141 };
142
143 struct line {
144         double x1, y1, x2, y2;
145 };
146
147 struct irect {
148         int x, y, width, height;
149 };
150
151 struct ipoint {
152         int x, y;
153 };
154
155 typedef enum {
156         ELMT_NONE=0,
157         ELMT_RECT=1,
158         ELMT_LINE=2,
159         ELMT_ARC=3
160 } ElementType;
161
162 struct rect_params {
163         struct rect dim;
164         gint filled;
165 };
166
167 struct line_params {
168         struct line dim;
169 };
170
171 struct arc_params {
172         struct rect dim;
173         gint filled;
174         gint angle1, angle2;
175 };
176
177 struct element {
178         ElementType type;
179         GdkGC *gc;
180         struct segment *parent;
181         union {
182                 struct arc_params arc;
183                 struct rect_params rect;
184                 struct line_params line;
185         } p;
186 };
187
188 struct element_list {
189         struct element_list *next;
190         struct element *elements;
191 };
192
193 struct axis {
194         struct graph *g;                        /* which graph we belong to */
195         GtkWidget *drawing_area;
196         GdkPixmap *pixmap[2];
197         int displayed;
198 #define AXIS_ORIENTATION        1 << 0
199         int flags;
200         /* dim and orig (relative to origin of window) of axis' pixmap */
201         struct irect p;
202         /* dim and orig (relative to origin of axis' pixmap) of scale itself */
203         struct irect s;
204         gdouble min, max;
205         gdouble major, minor;           /* major and minor ticks */
206         char **label;
207 };
208
209 #define HAXIS_INIT_HEIGHT       70
210 #define VAXIS_INIT_WIDTH        100
211 #define TITLEBAR_HEIGHT         50
212 #define RMARGIN_WIDTH   30
213
214 struct style_tseq_tcptrace {
215         GdkGC *gc_seq;
216         GdkGC *gc_ack[2];
217         int flags;
218 };
219
220 struct style_tseq_stevens {
221         int seq_width;
222         int seq_height;
223         int flags;
224 };
225
226 struct style_tput {
227         int width, height;
228         int nsegs;
229         int flags;
230 };
231
232 struct style_rtt {
233         int width, height;
234         int flags;
235 };
236
237 /* style flags */
238 #define SEQ_ORIGIN                      0x1
239 /* show absolute sequence numbers (not differences from isn) */
240 #define SEQ_ORIGIN_ZERO         0x1
241 #define SEQ_ORIGIN_ISN          0x0
242 #define TIME_ORIGIN                     0x10
243 /* show time from beginning of capture as opposed to time from beginning
244  * of the connection */
245 #define TIME_ORIGIN_CAP         0x10
246 #define TIME_ORIGIN_CONN        0x0
247
248 /* this is used by rtt module only */
249 struct unack {
250         struct unack *next;
251         double time;
252         unsigned int seqno;
253 };
254
255 struct cross {
256         int x, y;
257         int draw;                       /* indicates whether we should draw cross at all */
258         int erase_needed;
259         GtkToggleButton *on_toggle;
260         GtkToggleButton *off_toggle;
261 };
262
263 struct bounds {
264         double x0, y0, width, height;
265 };
266
267 struct zoom {
268         double x, y;
269 };
270
271 struct zooms {
272         double x, y;
273         double step_x, step_y;
274         struct zoom initial;
275 #define ZOOM_OUT                                (1 << 0)
276 #define ZOOM_HLOCK                              (1 << 1)
277 #define ZOOM_VLOCK                              (1 << 2)
278 #define ZOOM_STEPS_SAME                 (1 << 3)
279 #define ZOOM_STEPS_KEEP_RATIO   (1 << 4)
280         int flags;
281         /* unfortunately, we need them both because gtk_toggle_button_set_active ()
282          * with second argument FALSE doesn't do anything, somehow */
283         struct {
284                 GtkToggleButton *in_toggle;
285                 GtkToggleButton *out_toggle;
286                 GtkEntry *h_zoom;
287                 GtkEntry *v_zoom;
288                 GtkSpinButton *h_step;
289                 GtkSpinButton *v_step;
290         } widget;
291 };
292
293 struct grab {
294         int grabbed;
295         int x, y;
296 };
297
298 struct magnify {
299         int active;
300         int x, y;
301         struct ipoint offset;
302         int width, height;
303         struct zoom zoom;
304         struct graph *g;
305 #define MAGZOOMS_SAME           (1 << 0)
306 #define MAGZOOMS_SAME_RATIO     (1 << 1)
307 #define MAGZOOMS_IGNORE         (1 << 31)
308         int flags;
309         struct {
310                 GtkSpinButton *h_zoom, *v_zoom;
311         } widget;
312 };
313
314 struct graph {
315         struct graph *next;
316 #define GRAPH_TSEQ_STEVENS      0
317 #define GRAPH_TSEQ_TCPTRACE     1
318 #define GRAPH_THROUGHPUT        2
319 #define GRAPH_RTT                       3
320         int type;
321 #define GRAPH_DESTROYED                         (1 << 0)
322 #define GRAPH_INIT_ON_TYPE_CHANGE       (1 << 1)
323         int flags;
324         GtkWidget *toplevel;    /* keypress handler needs this */
325         GtkWidget *drawing_area;
326         GtkWidget *text;        /* text widget for seg list - probably
327                                  * temporary */
328 #if GTK_MAJOR_VERSION < 2
329         GdkFont *font;                  /* font used for annotations etc. */
330 #else
331         PangoFontDescription *font;     /* font used for annotations etc. */
332 #endif
333         GdkGC *fg_gc;
334         GdkGC *bg_gc;
335         GdkPixmap *title_pixmap;
336         GdkPixmap *pixmap[2];
337         int displayed;                  /* which of both pixmaps is on screen right now */
338         struct {
339                 GtkWidget *control_panel;
340                 /* this belongs to style structs of graph types that make use of it */
341                 GtkToggleButton *time_orig_conn, *seq_orig_isn;
342         } gui;
343         char **title;
344         /* Next 4 attribs describe the graph in natural units, before any scaling.
345          * For example, if we want to display graph of TCP conversation that
346          * started 112.309845 s after beginning of the capture and ran until
347          * 479.093582 s, 237019 B went through the connection (in one direction)
348          * starting with isn 31934022, then (bounds.x0, bounds.y0)=(112.309845,
349          * 31934022) and (bounds.width, bounds.height)=(366.783737, 237019). */
350         struct bounds bounds;
351         /* dimensions and position of the graph, both expressed already in pixels.
352          * x and y give the position of upper left corner of the graph relative
353          * to origin of the graph window, size is basically bounds*zoom */
354         struct irect geom;
355         /* viewport (=graph window area which is reserved for graph itself), its
356          * size and position relative to origin of the graph window */
357         struct irect wp;
358         struct grab grab;
359         /* If we need to display 237019 sequence numbers (=bytes) onto say 500
360          * pixels, we have to scale the graph down by factor of 0.002109. This
361          * number would be zoom.y. Obviously, both directions have separate zooms.*/
362         struct zooms zoom;
363         struct cross cross;
364         struct magnify magnify;
365         struct axis *x_axis, *y_axis;
366         struct segment *segments;
367         struct segment *current;
368         struct element_list *elists;            /* element lists */
369         union {
370                 struct style_tseq_stevens tseq_stevens;
371                 struct style_tseq_tcptrace tseq_tcptrace;
372                 struct style_tput tput;
373                 struct style_rtt rtt;
374         } s;
375 };
376
377 static struct graph *graphs = NULL;
378 static GdkGC *xor_gc = NULL;
379 static int refnum=0;
380
381 #define debug(section) if (debugging & section)
382 /* print function entry points */
383 #define DBS_FENTRY                      (1 << 0)
384 #define DBS_AXES_TICKS          (1 << 1)
385 #define DBS_AXES_DRAWING        (1 << 2)
386 #define DBS_GRAPH_DRAWING       (1 << 3)
387 #define DBS_TPUT_ELMTS          (1 << 4)
388 /*int debugging = DBS_FENTRY;*/
389 int debugging = 0;
390 /*int debugging = DBS_AXES_TICKS;*/
391 /*int debugging = DBS_AXES_DRAWING;*/
392 /*int debugging = DBS_GRAPH_DRAWING;*/
393 /*int debugging = DBS_TPUT_ELMTS;*/
394
395 static void create_gui (struct graph * );
396 #if 0
397 static void create_text_widget (struct graph * );
398 static void display_text (struct graph * );
399 #endif
400 static void create_drawing_area (struct graph * );
401 static void control_panel_create (struct graph * );
402 static GtkWidget *control_panel_create_zoom_group (struct graph * );
403 static GtkWidget *control_panel_create_magnify_group (struct graph * );
404 static GtkWidget *control_panel_create_cross_group (struct graph * );
405 static GtkWidget *control_panel_create_zoomlock_group (struct graph * );
406 static GtkWidget *control_panel_create_graph_type_group (struct graph * );
407 static void control_panel_add_zoom_page (struct graph * , GtkWidget * );
408 static void control_panel_add_magnify_page (struct graph * , GtkWidget * );
409 static void control_panel_add_origin_page (struct graph * , GtkWidget * );
410 static void control_panel_add_cross_page (struct graph * , GtkWidget * );
411 static void control_panel_add_graph_type_page (struct graph * , GtkWidget * );
412 static void callback_toplevel_destroy (GtkWidget * , gpointer );
413 static void callback_close (GtkWidget * , gpointer );
414 static void callback_time_origin (GtkWidget * , gpointer );
415 static void callback_seq_origin (GtkWidget * , gpointer );
416 static void callback_zoomlock_h (GtkWidget * , gpointer );
417 static void callback_zoomlock_v (GtkWidget * , gpointer );
418 static void callback_zoom_inout (GtkWidget * , gpointer );
419 static void callback_zoom_step (GtkWidget * , gpointer );
420 static void callback_zoom_flags (GtkWidget * , gpointer );
421 static void callback_cross_on_off (GtkWidget * , gpointer );
422 static void callback_mag_width (GtkWidget * , gpointer );
423 static void callback_mag_height (GtkWidget * , gpointer );
424 static void callback_mag_x (GtkWidget * , gpointer );
425 static void callback_mag_y (GtkWidget * , gpointer );
426 static void callback_mag_zoom (GtkWidget * , gpointer );
427 static void callback_mag_flags (GtkWidget * , gpointer );
428 static void callback_graph_type (GtkWidget * , gpointer );
429 static void callback_graph_init_on_typechg (GtkWidget * , gpointer );
430 static void callback_create_help (GtkWidget * , gpointer );
431 static void callback_close_help (GtkWidget * , gpointer );
432 static void update_zoom_spins (struct graph * );
433 static int get_headers (frame_data *, char * , struct segment * );
434 static int compare_headers (struct segment * , struct segment * , int );
435 static int get_num_dsegs (struct graph * );
436 static int get_num_acks (struct graph * );
437 static void graph_type_dependent_initialize (struct graph * );
438 static void graph_put (struct graph * );
439 static struct graph *graph_new (void);
440 static void graph_destroy (struct graph * );
441 static void graph_initialize_values (struct graph * );
442 static void graph_init_sequence (struct graph * );
443 static void draw_element_line (struct graph * , struct element * );
444 static void draw_element_arc (struct graph * , struct element * );
445 static void graph_display (struct graph * );
446 static void graph_pixmaps_create (struct graph * );
447 static void graph_pixmaps_switch (struct graph * );
448 static void graph_pixmap_draw (struct graph * );
449 static void graph_pixmap_display (struct graph * );
450 static void graph_element_lists_make (struct graph * );
451 static void graph_element_lists_free (struct graph * );
452 static void graph_element_lists_initialize (struct graph * );
453 static void graph_title_pixmap_create (struct graph * );
454 static void graph_title_pixmap_draw (struct graph * );
455 static void graph_title_pixmap_display (struct graph * );
456 static void graph_segment_list_get (struct graph * );
457 static void graph_segment_list_free (struct graph * );
458 static void graph_select_segment (struct graph * , int , int );
459 static int line_detect_collision (struct element * , int , int );
460 static int arc_detect_collision (struct element * , int , int );
461 static void axis_pixmaps_create (struct axis * );
462 static void axis_pixmaps_switch (struct axis * );
463 static void axis_display (struct axis * );
464 static void v_axis_pixmap_draw (struct axis * );
465 static void h_axis_pixmap_draw (struct axis * );
466 static void axis_pixmap_display (struct axis * );
467 static void axis_compute_ticks (struct axis * , double , double , int );
468 static double axis_zoom_get (struct axis * , int );
469 static void axis_ticks_up (int * , int * );
470 static void axis_ticks_down (int * , int * );
471 static void axis_destroy (struct axis * );
472 static int get_label_dim (struct axis * , int , double );
473 static void toggle_time_origin (struct graph * );
474 static void toggle_seq_origin (struct graph * );
475 static void cross_xor (struct graph * , int , int );
476 static void cross_draw (struct graph * , int , int );
477 static void cross_erase (struct graph * );
478 static void magnify_create (struct graph * , int , int );
479 static void magnify_move (struct graph * , int , int );
480 static void magnify_destroy (struct graph * );
481 static void magnify_draw (struct graph * );
482 static void magnify_get_geom (struct graph * , int , int );
483 static gint configure_event (GtkWidget * , GdkEventConfigure * );
484 static gint expose_event (GtkWidget * , GdkEventExpose * );
485 static gint button_press_event (GtkWidget * , GdkEventButton * );
486 static gint button_release_event (GtkWidget * , GdkEventButton * );
487 static gint motion_notify_event (GtkWidget * , GdkEventMotion * );
488 static gint key_press_event (GtkWidget * , GdkEventKey * );
489 static gint key_release_event (GtkWidget * , GdkEventKey * );
490 static gint leave_notify_event (GtkWidget * , GdkEventCrossing * );
491 static gint enter_notify_event (GtkWidget * , GdkEventCrossing * );
492 static void tseq_stevens_initialize (struct graph * );
493 static void tseq_stevens_get_bounds (struct graph * );
494 static void tseq_stevens_read_config (struct graph * );
495 static void tseq_stevens_make_elmtlist (struct graph * );
496 static void tseq_stevens_toggle_seq_origin (struct graph * );
497 static void tseq_stevens_toggle_time_origin (struct graph * );
498 static void tseq_tcptrace_read_config (struct graph * );
499 static void tseq_tcptrace_make_elmtlist (struct graph * );
500 static void tseq_tcptrace_toggle_seq_origin (struct graph * );
501 static void tseq_tcptrace_toggle_time_origin (struct graph * );
502 static void tput_initialize (struct graph * );
503 static void tput_read_config (struct graph * );
504 static void tput_make_elmtlist (struct graph * );
505 static void tput_toggle_time_origin (struct graph * );
506 static void rtt_read_config (struct graph * );
507 static void rtt_initialize (struct graph * );
508 static int rtt_is_retrans (struct unack * , unsigned int );
509 static struct unack *rtt_get_new_unack (double , unsigned int );
510 static void rtt_put_unack_on_list (struct unack ** , struct unack * );
511 static void rtt_delete_unack_from_list (struct unack ** , struct unack * );
512 static void rtt_make_elmtlist (struct graph * );
513 static void rtt_toggle_seq_origin (struct graph * );
514 #if defined(WIN32) && !defined(__MINGW32__)
515 static int rint (double );      /* compiler template for Windows */
516 #endif
517
518 static char helptext[] =
519 #ifndef WIN32
520 "Here's what you can do:\n\
521 - Left Mouse Button selects segment in ethereal's packet list\n\
522 - Middle Mouse Button zooms in\n\
523 - <shift>-Middle Button zooms out\n\
524 - Right Mouse Button moves the graph (if zoomed in)\n\
525 - <ctrl>-Right Mouse Button displays a portion of graph magnified\n\
526 - Space toggles crosshairs\n\
527 - 's' toggles relative/absolute sequence numbers\n\
528 - 't' toggles time origin\n\
529 ";
530 #else /* WIN32 */
531 "Here's what you can do:\n\
532 - <ctrl>-Left  Mouse Button selects segment in ethereal's packet list\n\
533 - Left         Mouse Button zooms in\n\
534 - <shift>-Left Mouse Button zooms out\n\
535 - Right        Mouse Button moves the graph (if zoomed in)\n\
536 - <ctrl>-Right Mouse Button displays a portion of graph magnified\n\
537 \n\
538 - Space bar toggles crosshairs\n\
539 - 's' - Toggles relative/absolute sequence numbers\n\
540 - 't' - Toggles time origin\n\
541 ";
542 #endif
543
544 void tcp_graph_cb (GtkWidget *w _U_, gpointer data, guint callback_action /*graph_type*/ _U_)
545 {
546         struct segment current;
547         struct graph *g;
548     guint graph_type = GPOINTER_TO_INT(data);
549
550         debug(DBS_FENTRY) puts ("tcp_graph_cb()");
551
552         if (! (g = graph_new()))
553                 return;
554
555         refnum++;
556         graph_initialize_values (g);
557         graph_put (g);
558
559         g->type = graph_type;
560         if (!get_headers (cfile.current_frame, cfile.pd, &current)) {
561                 /* currently selected packet is neither TCP over IP over Ethernet II/PPP
562                  * nor TCP over IP alone - should display some
563                  * kind of warning dialog */
564                 simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
565                     "Selected packet is not a TCP segment");
566                 return;
567         }
568
569         graph_segment_list_get(g);
570         create_gui(g);
571         /* display_text(g); */
572         graph_init_sequence(g);
573 }
574
575 static void create_gui (struct graph *g)
576 {
577         debug(DBS_FENTRY) puts ("create_gui()");
578         /* create_text_widget(g); */
579         control_panel_create (g);
580         create_drawing_area(g);
581 }
582
583 #if 0
584 static void create_text_widget (struct graph *g)
585 {
586         GtkWidget *streamwindow, *txt_scrollw, *box;
587
588         debug(DBS_FENTRY) puts ("create_text_widget()");
589         streamwindow = window_new (GTK_WINDOW_TOPLEVEL, "Ethereal: Packet chain");
590         gtk_widget_set_name (streamwindow, "Packet chain");
591         WIDGET_SET_SIZE(streamwindow, TXT_WIDTH, TXT_HEIGHT);
592         gtk_container_border_width (GTK_CONTAINER(streamwindow), 2);
593
594         box = gtk_vbox_new (FALSE, 0);
595         gtk_container_add (GTK_CONTAINER (streamwindow), box);
596         gtk_widget_show (box);
597
598         txt_scrollw = scrolled_window_new (NULL, NULL);
599 #if GTK_MAJOR_VERSION >= 2
600     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(txt_scrollw), 
601                                    GTK_SHADOW_IN);
602 #endif
603         gtk_box_pack_start (GTK_BOX (box), txt_scrollw, TRUE, TRUE, 0);
604         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (txt_scrollw),
605                                         GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
606         gtk_widget_show (txt_scrollw);
607
608 #if GTK_MAJOR_VERSION < 2
609         g->text = gtk_text_new(NULL, NULL);
610         gtk_text_set_editable(GTK_TEXT(g->text), FALSE);
611 #else
612         g->text = gtk_text_view_new();
613         gtk_text_view_set_editable(GTK_TEXT_VIEW(g->text), FALSE);
614 #endif
615         gtk_container_add (GTK_CONTAINER (txt_scrollw), g->text);
616         gtk_widget_show (g->text);
617         gtk_widget_show (streamwindow);
618 }
619 static void display_text (struct graph *g)
620 {
621         char *line[256];
622         struct segment *ptr;
623         double first_time, prev_time;
624         unsigned int isn_this=0, isn_opposite=0, seq_this_prev, seq_opposite_prev;
625         GdkColor color, *c;
626 #if GTK_MAJOR_VERSION >= 2
627         GtkTextBuffer *buf;
628         GtkTextIter    iter;
629 #endif
630
631         debug(DBS_FENTRY) puts ("display_text()");
632         if (!gdk_color_parse ("SlateGray", &color)) {
633                 /*
634                  * XXX - do more than just warn.
635                  */
636                 simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
637                     "Could not parse color SlateGray.");
638         }
639 #if GTK_MAJOR_VERSION < 2
640         gtk_text_freeze (GTK_TEXT (g->text));
641 #endif
642         snprintf ((char * )line, 256, "%10s%15s%15s%15s%15s%15s%15s%10s\n",
643                                         "pkt num", "time", "delta first", "delta prev",
644                                         "seqno", "delta first", "delta prev", "data (B)");
645         gtk_text_insert (GTK_TEXT (g->text), g->font, NULL, NULL,
646                                                         (const char *)line, -1);
647
648         first_time = g->segments->rel_secs + g->segments->rel_usecs/1000000.0;
649         prev_time = first_time;
650         /* we have to find Initial Sequence Number for both ends of connection */
651         for (ptr=g->segments; ptr; ptr=ptr->next) {
652                 if (compare_headers (g->current, ptr, COMPARE_CURR_DIR)) {
653                         isn_this = g_ntohl (ptr->tcphdr.seq);
654                         break;
655                 }
656         }
657         for (ptr=g->segments; ptr; ptr=ptr->next) {
658                 if (!compare_headers (g->current, ptr, COMPARE_CURR_DIR)) {
659                         isn_opposite = g_ntohl (ptr->tcphdr.seq);
660                         break;
661                 }
662         }
663         seq_this_prev = isn_this;
664         seq_opposite_prev = isn_opposite;
665         for (ptr=g->segments; ptr; ptr=ptr->next) {
666                 double time=ptr->rel_secs + ptr->rel_usecs/1000000.0;
667                 unsigned int seq = g_ntohl (ptr->tcphdr.seq);
668                 int seq_delta_isn, seq_delta_prev;
669
670                 if (compare_headers (g->current, ptr, COMPARE_CURR_DIR)) {
671                         seq_delta_isn = seq - isn_this;
672                         seq_delta_prev = seq - seq_this_prev;
673                         seq_this_prev = seq;
674                         c = NULL;
675                 } else {
676                         seq_delta_isn = seq - isn_opposite;
677                         seq_delta_prev = seq - seq_opposite_prev;
678                         seq_opposite_prev = seq;
679                         c = &color;
680                 }
681                 snprintf ((char *)line, 256, "%10d%15.6f%15.6f%15.6f%15u%15d%15d%10u\n",
682                                                 ptr->num, time, time-first_time, time-prev_time,
683                                                 seq, seq_delta_isn, seq_delta_prev,
684                                                 g_ntohs (ptr->iphdr.tot_len) - 4*IHL(&(ptr->iphdr)) -
685                                                 4*DOFF(ptr->tcphdr));
686 #if GTK_MAJOR_VERSION < 2
687                 gtk_text_insert(GTK_TEXT(g->text), g->font, c, NULL,
688                                 (const char * )line, -1);
689 #else
690                 gtk_text_buffer_insert(buf, &iter, (const char *)line, -1);
691 #endif
692                 prev_time = time;
693         }
694 #if GTK_MAJOR_VERSION < 2
695         gtk_text_thaw (GTK_TEXT (g->text));
696 #endif
697 }
698 #endif
699
700 static void create_drawing_area (struct graph *g)
701 {
702         GdkColormap *colormap;
703         GdkColor color;
704 #define WINDOW_TITLE_LENGTH 64
705         char window_title[WINDOW_TITLE_LENGTH];
706
707         debug(DBS_FENTRY) puts ("create_drawing_area()");
708 #if 0
709         g->font = gdk_font_load ("-sony-fixed-medium-r-normal--16-150-75-75"
710                                                         "-c-80-iso8859-2");
711         g->font = gdk_font_load ("-biznet-fotinostypewriter-medium-r-normal-*-*-120"
712                                                         "-*-*-m-*-iso8859-2");
713 #endif
714         snprintf (window_title, WINDOW_TITLE_LENGTH, "TCP Graph %d - Ethereal",
715                                         refnum);
716         g->toplevel = window_new (GTK_WINDOW_TOPLEVEL, window_title);
717         gtk_widget_set_name (g->toplevel, "Test Graph");
718
719         /* Create the drawing area */
720         g->drawing_area = gtk_drawing_area_new ();
721         g->x_axis->drawing_area = g->y_axis->drawing_area = g->drawing_area;
722         gtk_drawing_area_size (GTK_DRAWING_AREA (g->drawing_area),
723                                         g->wp.width + g->wp.x + RMARGIN_WIDTH,
724                                         g->wp.height + g->wp.y + g->x_axis->s.height);
725         gtk_widget_show (g->drawing_area);
726
727         SIGNAL_CONNECT(g->drawing_area, "expose_event", expose_event, NULL);
728         /* this has to be done later, after the widget has been shown */
729         /*
730         SIGNAL_CONNECT(g->drawing_area,"configure_event", configure_event,
731         NULL);
732          */
733         SIGNAL_CONNECT(g->drawing_area, "motion_notify_event",
734                        motion_notify_event, NULL);
735         SIGNAL_CONNECT(g->drawing_area, "button_press_event",
736                        button_press_event, NULL);
737         SIGNAL_CONNECT(g->drawing_area, "button_release_event",
738                        button_release_event, NULL);
739         SIGNAL_CONNECT(g->drawing_area, "leave_notify_event",
740                        leave_notify_event, NULL);
741         SIGNAL_CONNECT(g->drawing_area, "enter_notify_event",
742                        enter_notify_event, NULL);
743         SIGNAL_CONNECT(g->toplevel, "destroy", callback_toplevel_destroy, g);
744         /* why doesn't drawing area send key_press_signals? */
745         SIGNAL_CONNECT(g->toplevel, "key_press_event", key_press_event, NULL);
746         SIGNAL_CONNECT(g->toplevel, "key_release_event", key_release_event,
747                        NULL);
748         gtk_widget_set_events(g->toplevel,
749                               GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK);
750
751         gtk_widget_set_events (g->drawing_area,
752                                GDK_EXPOSURE_MASK
753                                | GDK_LEAVE_NOTIFY_MASK
754                                | GDK_ENTER_NOTIFY_MASK
755                                | GDK_BUTTON_PRESS_MASK
756                                | GDK_BUTTON_RELEASE_MASK
757                                | GDK_POINTER_MOTION_MASK
758                                | GDK_POINTER_MOTION_HINT_MASK);
759
760 #if 0
761         frame = gtk_frame_new (NULL);
762         gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_ETCHED_IN);
763         gtk_container_add (GTK_CONTAINER (frame), g->drawing_area);
764
765         box = gtk_hbox_new (FALSE, 0);
766         gtk_box_pack_start (GTK_BOX (box), g->gui.control_panel, FALSE, FALSE, 0);
767         gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 0);
768         gtk_container_add (GTK_CONTAINER (g->toplevel), box);
769         gtk_container_set_border_width (GTK_CONTAINER (g->toplevel), 5);
770         gtk_widget_show (frame);
771         gtk_widget_show (box);
772 #endif
773
774         gtk_container_add (GTK_CONTAINER (g->toplevel), g->drawing_area);
775         gtk_widget_show (g->toplevel);
776
777         /* in case we didn't get what we asked for */
778         g->wp.width = GTK_WIDGET (g->drawing_area)->allocation.width -
779                                                 g->wp.x - RMARGIN_WIDTH;
780         g->wp.height = GTK_WIDGET (g->drawing_area)->allocation.height -
781                                                 g->wp.y - g->x_axis->s.height;
782
783 #if GTK_MAJOR_VERSION < 2
784         g->font = g->drawing_area->style->font;
785         gdk_font_ref (g->font);
786 #else
787         g->font = g->drawing_area->style->font_desc;
788 #endif
789
790         colormap = gdk_window_get_colormap (g->drawing_area->window);
791         if (!xor_gc) {
792                 xor_gc = gdk_gc_new (g->drawing_area->window);
793                 gdk_gc_set_function (xor_gc, GDK_XOR);
794                 if (!gdk_color_parse ("gray15", &color)) {
795                         /*
796                          * XXX - do more than just warn.
797                          */
798                         simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
799                             "Could not parse color gray15.");
800                 }
801                 if (!gdk_colormap_alloc_color (colormap, &color, FALSE, TRUE)) {
802                         /*
803                          * XXX - do more than just warn.
804                          */
805                         simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
806                             "Could not allocate color gray15.");
807                 }
808                 gdk_gc_set_foreground (xor_gc, &color);
809         }
810         g->fg_gc = gdk_gc_new (g->drawing_area->window);
811         g->bg_gc = gdk_gc_new (g->drawing_area->window);
812         if (!gdk_color_parse ("white", &color)) {
813                 /*
814                  * XXX - do more than just warn.
815                  */
816                 simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
817                     "Could not parse color white.");
818         }
819         if (!gdk_colormap_alloc_color (colormap, &color, FALSE, TRUE)) {
820                 /*
821                  * XXX - do more than just warn.
822                  */
823                 simple_dialog(ESD_TYPE_WARN, ESD_BTN_OK,
824                     "Could not allocate color white.");
825         }
826         gdk_gc_set_foreground (g->bg_gc, &color);
827
828         /* this is probably quite an ugly way to get rid of the first configure
829          * event
830          * immediatelly after gtk_widget_show (window) drawing_area gets a configure
831          * event which is handled during the next return to gtk_main which is
832          * probably the gdk_gc_new() call. configure handler calls
833          * graph_element_lists_make() which is not good because the graph struct is
834          * not fully set up yet - namely we're not sure about actual geometry
835          * and we don't have the GC's at all. so we just postpone installation
836          * of configure handler until we're ready to deal with it.
837          *
838          * !!! NEMÌLO BY TO BÝT NA KONCI graph_init_sequence()? !!!
839          *
840          */
841         SIGNAL_CONNECT(g->drawing_area,"configure_event", configure_event,
842                        NULL);
843
844         /* puts ("exiting create_drawing_area()"); */
845 }
846
847 static void callback_toplevel_destroy (GtkWidget *widget _U_, gpointer data)
848 {
849         struct graph *g = (struct graph * )data;
850
851         if (!(g->flags & GRAPH_DESTROYED)) {
852                 g->flags |= GRAPH_DESTROYED;
853                 graph_destroy ((struct graph * )data);
854         }
855 }
856
857 static void control_panel_create (struct graph *g)
858 {
859         GtkWidget *toplevel, *notebook;
860         GtkWidget *table;
861         GtkWidget *help_bt, *close_bt, *bbox;
862 #define WINDOW_TITLE_LENGTH 64
863         char window_title[WINDOW_TITLE_LENGTH];
864
865         debug(DBS_FENTRY) puts ("control_panel_create()");
866
867         notebook = gtk_notebook_new ();
868         control_panel_add_zoom_page (g, notebook);
869         control_panel_add_magnify_page (g, notebook);
870         control_panel_add_origin_page (g, notebook);
871         control_panel_add_cross_page (g, notebook);
872         control_panel_add_graph_type_page (g, notebook);
873
874         snprintf (window_title, WINDOW_TITLE_LENGTH,
875                                 "Graph %d - Control - Ethereal", refnum);
876         toplevel = window_new (GTK_WINDOW_TOPLEVEL, window_title);
877         SIGNAL_CONNECT(toplevel, "destroy", callback_toplevel_destroy, g);
878
879         table = gtk_table_new (2, 1,  FALSE);
880         gtk_container_add (GTK_CONTAINER (toplevel), table);
881
882         gtk_table_attach (GTK_TABLE (table), notebook, 0, 1, 0, 1,
883                           GTK_FILL|GTK_EXPAND, GTK_FILL, 5, 5);
884
885         /* bottom buttons */
886         bbox = dlg_button_row_new(GTK_STOCK_HELP, GTK_STOCK_CLOSE, NULL);
887         gtk_table_attach (GTK_TABLE (table), bbox, 0, 1, 1, 2,
888                           GTK_FILL|GTK_EXPAND, GTK_FILL, 5, 5);
889         gtk_widget_show(bbox);
890
891         help_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_HELP);
892         SIGNAL_CONNECT(help_bt, "clicked", callback_create_help, g);
893
894         close_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_CLOSE);
895         gtk_widget_grab_default(close_bt);
896         SIGNAL_CONNECT(close_bt, "clicked", callback_close, g);
897
898         /* gtk_widget_show_all (table); */
899         /* g->gui.control_panel = table; */
900         gtk_widget_show_all (toplevel);
901         g->gui.control_panel = toplevel;
902 }
903
904 static void control_panel_add_zoom_page (struct graph *g, GtkWidget *n)
905 {
906         GtkWidget *zoom_frame;
907         GtkWidget *zoom_lock_frame;
908         GtkWidget *label;
909         GtkWidget *box;
910
911         zoom_frame = control_panel_create_zoom_group (g);
912         gtk_container_set_border_width (GTK_CONTAINER (zoom_frame), 5);
913         zoom_lock_frame = control_panel_create_zoomlock_group (g);
914         gtk_container_set_border_width (GTK_CONTAINER (zoom_lock_frame), 5);
915         box = gtk_vbox_new (FALSE, 0);
916         gtk_box_pack_start (GTK_BOX (box), zoom_frame, TRUE, TRUE, 0);
917         gtk_box_pack_start (GTK_BOX (box), zoom_lock_frame, TRUE, TRUE, 0);
918         gtk_widget_show (box);
919         label = gtk_label_new ("Zoom");
920         gtk_notebook_append_page (GTK_NOTEBOOK (n), box, label);
921 }
922
923 static void control_panel_add_magnify_page (struct graph *g, GtkWidget *n)
924 {
925         GtkWidget *mag_frame, *label;
926
927         mag_frame = control_panel_create_magnify_group (g);
928         gtk_container_set_border_width (GTK_CONTAINER (mag_frame), 5);
929         label = gtk_label_new ("Magnify");
930         gtk_notebook_append_page (GTK_NOTEBOOK (n), mag_frame, label);
931 }
932
933 static void control_panel_add_origin_page (struct graph *g, GtkWidget *n)
934 {
935         GtkWidget *time_orig_cap, *time_orig_conn, *time_orig_box, *time_orig_frame;
936         GtkWidget *seq_orig_isn, *seq_orig_zero, *seq_orig_box, *seq_orig_frame;
937         GtkWidget *box, *label;
938
939         /* time origin box */
940         time_orig_cap =
941                         gtk_radio_button_new_with_label (NULL, "beginning of capture");
942         time_orig_conn = gtk_radio_button_new_with_label (
943                         gtk_radio_button_group (GTK_RADIO_BUTTON (time_orig_cap)),
944                         "beginning of this TCP connection");
945         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (time_orig_conn), TRUE);
946         time_orig_box = gtk_vbox_new (TRUE, 0);
947         gtk_box_pack_start (GTK_BOX (time_orig_box), time_orig_conn, TRUE, TRUE, 0);
948         gtk_box_pack_start (GTK_BOX (time_orig_box), time_orig_cap, TRUE, TRUE, 0);
949         time_orig_frame = gtk_frame_new ("Time origin");
950         gtk_container_set_border_width (GTK_CONTAINER (time_orig_frame), 5);
951         gtk_container_add (GTK_CONTAINER (time_orig_frame), time_orig_box);
952
953         /* sequence number origin group */
954         seq_orig_isn =
955                         gtk_radio_button_new_with_label (NULL, "initial sequence number");
956         seq_orig_zero = gtk_radio_button_new_with_label (gtk_radio_button_group (
957                         GTK_RADIO_BUTTON (seq_orig_isn)), "0 (=absolute)");
958         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (seq_orig_isn), TRUE);
959         seq_orig_box = gtk_vbox_new (TRUE, 0);
960         gtk_box_pack_start (GTK_BOX (seq_orig_box), seq_orig_isn, TRUE, TRUE, 0);
961         gtk_box_pack_start (GTK_BOX (seq_orig_box), seq_orig_zero, TRUE, TRUE, 0);
962         seq_orig_frame = gtk_frame_new ("Sequence number origin");
963         gtk_container_set_border_width (GTK_CONTAINER (seq_orig_frame), 5);
964         gtk_container_add (GTK_CONTAINER (seq_orig_frame), seq_orig_box);
965
966         g->gui.time_orig_conn = (GtkToggleButton * )time_orig_conn;
967         g->gui.seq_orig_isn = (GtkToggleButton * )seq_orig_isn;
968
969         SIGNAL_CONNECT(time_orig_conn, "toggled", callback_time_origin, g);
970         SIGNAL_CONNECT(seq_orig_isn, "toggled", callback_seq_origin, g);
971
972         box = gtk_vbox_new (FALSE, 0);
973         gtk_container_set_border_width (GTK_CONTAINER (box), 5);
974         gtk_box_pack_start (GTK_BOX (box), time_orig_frame, TRUE, TRUE, 0);
975         gtk_box_pack_start (GTK_BOX (box), seq_orig_frame, TRUE, TRUE, 0);
976         gtk_widget_show (box);
977         label = gtk_label_new ("Origin");
978         gtk_notebook_append_page (GTK_NOTEBOOK (n), box, label);
979 }
980
981 static void control_panel_add_cross_page (struct graph *g, GtkWidget *n)
982 {
983         GtkWidget *cross_frame, *label;
984
985         cross_frame = control_panel_create_cross_group (g);
986         gtk_container_set_border_width (GTK_CONTAINER (cross_frame), 5);
987         label = gtk_label_new ("Cross");
988         gtk_notebook_append_page (GTK_NOTEBOOK (n), cross_frame, label);
989 }
990
991 static void control_panel_add_graph_type_page (struct graph *g, GtkWidget *n)
992 {
993         GtkWidget *frame, *label;
994
995         frame = control_panel_create_graph_type_group (g);
996         gtk_container_set_border_width (GTK_CONTAINER (frame), 5);
997         label = gtk_label_new ("Graph type");
998         gtk_notebook_append_page (GTK_NOTEBOOK (n), frame, label);
999 }
1000
1001 static void callback_close (GtkWidget *widget _U_, gpointer data)
1002 {
1003         struct graph *g = (struct graph * )data;
1004
1005         if (!(g->flags & GRAPH_DESTROYED)) {
1006                 g->flags |= GRAPH_DESTROYED;
1007                 graph_destroy ((struct graph * )data);
1008         }
1009 }
1010
1011 static void callback_create_help(GtkWidget *widget _U_, gpointer data _U_)
1012 {
1013         GtkWidget *toplevel, *box, *text, *scroll, *bbox, *close_bt;
1014 #if GTK_MAJOR_VERSION < 2
1015         struct graph *g = (struct graph * )data;
1016 #else
1017         GtkTextBuffer *buf;
1018 #endif
1019
1020         toplevel = window_new (GTK_WINDOW_TOPLEVEL, "Help for TCP graphing");
1021         WIDGET_SET_SIZE(toplevel, 500, 400);
1022
1023         box = gtk_vbox_new (FALSE, 0);
1024         gtk_container_add (GTK_CONTAINER (toplevel), box);
1025         scroll = scrolled_window_new (NULL, NULL);
1026 #if GTK_MAJOR_VERSION >= 2
1027     gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), 
1028                                    GTK_SHADOW_IN);
1029 #endif
1030         gtk_box_pack_start (GTK_BOX (box), scroll, TRUE, TRUE, 0);
1031 #if GTK_MAJOR_VERSION < 2
1032         text = gtk_text_new (NULL, NULL);
1033         gtk_text_set_editable (GTK_TEXT (text), FALSE);
1034         gtk_text_set_line_wrap (GTK_TEXT (text), FALSE);
1035         gtk_text_set_word_wrap (GTK_TEXT (text), FALSE);
1036         gtk_text_insert (GTK_TEXT (text), g->font, NULL, NULL, helptext, -1);
1037 #else
1038         text = gtk_text_view_new();
1039         gtk_text_view_set_editable(GTK_TEXT_VIEW(text), FALSE);
1040         buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(text));
1041         gtk_text_buffer_set_text(buf, helptext, -1);
1042 #endif
1043         gtk_container_add (GTK_CONTAINER (scroll), text);
1044
1045     bbox = dlg_button_row_new(GTK_STOCK_CLOSE, NULL);
1046         gtk_box_pack_start (GTK_BOX (box), bbox, FALSE, FALSE, 0);
1047     gtk_widget_show(bbox);
1048
1049     close_bt = OBJECT_GET_DATA(bbox, GTK_STOCK_CLOSE);
1050         SIGNAL_CONNECT(close_bt, "clicked", callback_close_help, toplevel);
1051     gtk_widget_grab_default(close_bt);
1052
1053         gtk_widget_show_all (toplevel);
1054 }
1055
1056 static void callback_close_help (GtkWidget *widget _U_, gpointer data)
1057 {
1058         gtk_widget_destroy ((GtkWidget * )data);
1059 }
1060
1061 static void callback_time_origin (GtkWidget *toggle _U_, gpointer data)
1062 {
1063         toggle_time_origin ((struct graph * )data);
1064 }
1065
1066 static void callback_seq_origin (GtkWidget *toggle _U_, gpointer data)
1067 {
1068         toggle_seq_origin ((struct graph * )data);
1069 }
1070
1071 static GtkWidget *control_panel_create_zoom_group (struct graph *g)
1072 {
1073         GtkWidget *zoom_in, *zoom_out, *zoom_box, *zoom_frame;
1074         GtkAdjustment *zoom_h_adj, *zoom_v_adj;
1075         GtkWidget *zoom_inout_box, *zoom_h_step_label, *zoom_h_step;
1076         GtkWidget *zoom_v_step_label, *zoom_v_step;
1077         GtkWidget *zoom_separator1, *zoom_separator2, *zoom_step_table, *zoom_table;
1078         GtkWidget *zoom_ratio_toggle, *zoom_same_toggle;
1079         GtkWidget *zoom_h_entry, *zoom_v_entry;
1080         GtkWidget *zoom_h_label, *zoom_v_label;
1081
1082         zoom_in = gtk_radio_button_new_with_label (NULL, "in");
1083         zoom_out = gtk_radio_button_new_with_label (
1084                                         gtk_radio_button_group (GTK_RADIO_BUTTON (zoom_in)), "out");
1085         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (zoom_in), TRUE);
1086         zoom_inout_box = gtk_hbox_new (FALSE, 0);
1087         gtk_box_pack_start (GTK_BOX (zoom_inout_box), zoom_in, FALSE, FALSE, 10);
1088         gtk_box_pack_start (GTK_BOX (zoom_inout_box), zoom_out, FALSE, FALSE, 0);
1089
1090         zoom_separator1 = gtk_hseparator_new ();
1091
1092         zoom_h_entry = gtk_entry_new ();
1093         gtk_entry_set_text (GTK_ENTRY (zoom_h_entry), "1.000");
1094         gtk_editable_set_editable (GTK_EDITABLE (zoom_h_entry), FALSE);
1095         zoom_h_label = gtk_label_new ("Horizontal:");
1096
1097         zoom_v_entry = gtk_entry_new ();
1098         gtk_entry_set_text (GTK_ENTRY (zoom_v_entry), "1.000");
1099         gtk_editable_set_editable (GTK_EDITABLE (zoom_v_entry), FALSE);
1100         zoom_v_label = gtk_label_new ("Vertical:");
1101
1102         g->zoom.widget.h_zoom = (GtkEntry * )zoom_h_entry;
1103         g->zoom.widget.v_zoom = (GtkEntry * )zoom_v_entry;
1104
1105         zoom_table = gtk_table_new (2, 2,  FALSE);
1106         gtk_table_attach (GTK_TABLE (zoom_table), zoom_h_label, 0,1,0,1,
1107                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1108         gtk_table_attach (GTK_TABLE (zoom_table), zoom_h_entry, 1, 2, 0, 1,
1109                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1110         gtk_table_attach (GTK_TABLE (zoom_table), zoom_v_label, 0,1,1,2,
1111                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1112         gtk_table_attach (GTK_TABLE (zoom_table), zoom_v_entry, 1, 2, 1, 2,
1113                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1114
1115         zoom_separator2 = gtk_hseparator_new ();
1116
1117         zoom_h_adj = (GtkAdjustment * )gtk_adjustment_new ((gfloat)1.2, 1.0, 5, (gfloat)0.1, 1, 0);
1118         zoom_h_step = gtk_spin_button_new (zoom_h_adj, 0, 1);
1119         gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (zoom_h_step), TRUE);
1120         zoom_h_step_label = gtk_label_new ("Horizontal step:");
1121
1122         zoom_v_adj = (GtkAdjustment * )gtk_adjustment_new ((gfloat)1.2, 1.0, 5, (gfloat)0.1, 1, 0);
1123         zoom_v_step = gtk_spin_button_new (zoom_v_adj, 0, 1);
1124         gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (zoom_v_step), TRUE);
1125         zoom_v_step_label = gtk_label_new ("Vertical step:");
1126
1127         g->zoom.widget.h_step = (GtkSpinButton * )zoom_h_step;
1128         g->zoom.widget.v_step = (GtkSpinButton * )zoom_v_step;
1129
1130         zoom_same_toggle = gtk_check_button_new_with_label("Keep them the same");
1131         zoom_ratio_toggle = gtk_check_button_new_with_label("Preserve their ratio");
1132         OBJECT_SET_DATA(zoom_same_toggle, "flag", (gpointer)ZOOM_STEPS_SAME);
1133         OBJECT_SET_DATA(zoom_ratio_toggle, "flag",
1134                         (gpointer)ZOOM_STEPS_KEEP_RATIO);
1135         SIGNAL_CONNECT(zoom_same_toggle, "clicked", callback_zoom_flags, g);
1136         SIGNAL_CONNECT(zoom_ratio_toggle, "clicked", callback_zoom_flags, g);
1137
1138         zoom_step_table = gtk_table_new (4, 2,  FALSE);
1139         gtk_table_attach (GTK_TABLE (zoom_step_table), zoom_h_step_label, 0,1,0,1,
1140                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1141         gtk_table_attach (GTK_TABLE (zoom_step_table), zoom_h_step, 1, 2, 0, 1,
1142                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1143         gtk_table_attach (GTK_TABLE (zoom_step_table), zoom_v_step_label, 0,1,1,2,
1144                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1145         gtk_table_attach (GTK_TABLE (zoom_step_table), zoom_v_step, 1, 2, 1, 2,
1146                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1147         gtk_table_attach (GTK_TABLE (zoom_step_table), zoom_same_toggle, 0,2,2,3,
1148                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1149         gtk_table_attach (GTK_TABLE (zoom_step_table), zoom_ratio_toggle, 0,2,3,4,
1150                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1151
1152         zoom_box = gtk_vbox_new (FALSE, 0);
1153         gtk_box_pack_start (GTK_BOX (zoom_box), zoom_inout_box, TRUE, TRUE, 0);
1154         gtk_box_pack_start (GTK_BOX (zoom_box), zoom_separator1, TRUE, TRUE, 0);
1155         gtk_box_pack_start (GTK_BOX (zoom_box), zoom_table, TRUE, TRUE, 0);
1156         gtk_box_pack_start (GTK_BOX (zoom_box), zoom_separator2, TRUE, TRUE, 0);
1157         gtk_box_pack_start (GTK_BOX (zoom_box), zoom_step_table, TRUE, TRUE, 0);
1158         zoom_frame = gtk_frame_new ("Zoom");
1159         gtk_container_add (GTK_CONTAINER (zoom_frame), zoom_box);
1160
1161         OBJECT_SET_DATA(zoom_h_step, "direction", GINT_TO_POINTER(0));
1162         OBJECT_SET_DATA(zoom_v_step, "direction", GINT_TO_POINTER(1));
1163
1164         SIGNAL_CONNECT(zoom_in, "toggled", callback_zoom_inout, g);
1165         SIGNAL_CONNECT(zoom_h_step, "changed", callback_zoom_step, g);
1166         SIGNAL_CONNECT(zoom_v_step, "changed", callback_zoom_step, g);
1167
1168         g->zoom.widget.in_toggle = (GtkToggleButton * )zoom_in;
1169         g->zoom.widget.out_toggle = (GtkToggleButton * )zoom_out;
1170         return zoom_frame;
1171 }
1172
1173 static void callback_zoom_inout (GtkWidget *toggle, gpointer data)
1174 {
1175         struct graph *g = (struct graph * )data;
1176
1177         if (GTK_TOGGLE_BUTTON (toggle)->active)
1178                 g->zoom.flags &= ~ZOOM_OUT;
1179         else
1180                 g->zoom.flags |= ZOOM_OUT;
1181 }
1182
1183 static void callback_zoom_step (GtkWidget *spin, gpointer data)
1184 {
1185         struct graph *g = (struct graph * )data;
1186         double value;
1187         int direction;
1188         double *zoom_this, *zoom_other;
1189         GtkSpinButton *widget_this, *widget_other;
1190         double old_this;
1191
1192         direction = (int)OBJECT_GET_DATA(spin, "direction");
1193         value = gtk_spin_button_get_value_as_float (GTK_SPIN_BUTTON (spin));
1194
1195         if (direction) {
1196                 zoom_this = &g->zoom.step_y;
1197                 zoom_other = &g->zoom.step_x;
1198                 widget_this = g->zoom.widget.v_step;
1199                 widget_other = g->zoom.widget.h_step;
1200         } else {
1201                 zoom_this = &g->zoom.step_x;
1202                 zoom_other = &g->zoom.step_y;
1203                 widget_this = g->zoom.widget.h_step;
1204                 widget_other = g->zoom.widget.v_step;
1205         }
1206
1207         old_this = *zoom_this;
1208         *zoom_this = value;
1209         if (g->zoom.flags & ZOOM_STEPS_SAME) {
1210                 *zoom_other = value;
1211                 gtk_spin_button_set_value (widget_other, (gfloat) *zoom_other);
1212         } else if (g->zoom.flags & ZOOM_STEPS_KEEP_RATIO) {
1213                 double old_other = *zoom_other;
1214                 *zoom_other *= value / old_this;
1215                 if (*zoom_other < 1.0) {
1216                         *zoom_other = 1.0;
1217                         *zoom_this = old_this * 1.0 / old_other;
1218                         gtk_spin_button_set_value (widget_this, (gfloat) *zoom_this);
1219                 } else if (*zoom_other > 5.0) {
1220                         *zoom_other = 5.0;
1221                         *zoom_this = old_this * 5.0 / old_other;
1222                         gtk_spin_button_set_value (widget_this, (gfloat) *zoom_this);
1223                 }
1224                 gtk_spin_button_set_value (widget_other, (gfloat) *zoom_other);
1225         }
1226 }
1227
1228 static void callback_zoom_flags (GtkWidget *toggle, gpointer data)
1229 {
1230         struct graph *g = (struct graph * )data;
1231         int flag = (int)OBJECT_GET_DATA(toggle, "flag");
1232
1233         if (GTK_TOGGLE_BUTTON (toggle)->active)
1234                 g->zoom.flags |= flag;
1235         else
1236                 g->zoom.flags &= ~flag;
1237 }
1238
1239 static void update_zoom_spins (struct graph *g)
1240 {
1241         char s[32];
1242
1243         snprintf (s, 32, "%.3f", g->zoom.x / g->zoom.initial.x);
1244         gtk_entry_set_text (g->zoom.widget.h_zoom, s);
1245         snprintf (s, 32, "%.3f", g->zoom.y / g->zoom.initial.y);
1246         gtk_entry_set_text (g->zoom.widget.v_zoom, s);
1247 }
1248
1249 static GtkWidget *control_panel_create_magnify_group (struct graph *g)
1250 {
1251         GtkWidget *mag_width_label, *mag_width;
1252         GtkWidget *mag_height_label, *mag_height;
1253         GtkWidget *mag_x_label, *mag_x;
1254         GtkWidget *mag_y_label, *mag_y;
1255         GtkWidget *mag_wh_table, *mag_zoom_frame, *mag_zoom_table;
1256         GtkWidget *mag_h_zoom_label, *mag_h_zoom;
1257         GtkWidget *mag_v_zoom_label, *mag_v_zoom;
1258         GtkWidget *mag_zoom_same, *mag_zoom_ratio;
1259         GtkAdjustment *mag_width_adj, *mag_height_adj, *mag_x_adj, *mag_y_adj;
1260         GtkAdjustment *mag_h_zoom_adj, *mag_v_zoom_adj;
1261         GtkWidget *mag_box, *mag_frame;
1262
1263         mag_width_label = gtk_label_new ("Width:");
1264         mag_width_adj = (GtkAdjustment * )gtk_adjustment_new (250,100,600,1,10,0);
1265         mag_width = gtk_spin_button_new (mag_width_adj, 0, 0);
1266
1267         mag_height_label = gtk_label_new ("Height:");
1268         mag_height_adj = (GtkAdjustment * )gtk_adjustment_new (250,100,600,1,10,0);
1269         mag_height = gtk_spin_button_new (mag_height_adj, 0, 0);
1270
1271         mag_x_label = gtk_label_new ("X:");
1272         mag_x_adj = (GtkAdjustment * )gtk_adjustment_new (0,-1000,1000,1,10,0);
1273         mag_x = gtk_spin_button_new (mag_x_adj, 0, 0);
1274
1275         mag_y_label = gtk_label_new ("Y:");
1276         mag_y_adj = (GtkAdjustment * )gtk_adjustment_new (0,-1000,1000,1,10,0);
1277         mag_y = gtk_spin_button_new (mag_y_adj, 0, 0);
1278
1279         mag_wh_table = gtk_table_new (4, 2, FALSE);
1280         gtk_table_attach (GTK_TABLE (mag_wh_table), mag_width_label, 0,1,0,1,
1281                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1282         gtk_table_attach (GTK_TABLE (mag_wh_table), mag_width, 1,2,0,1,
1283                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1284         gtk_table_attach (GTK_TABLE (mag_wh_table), mag_height_label, 0,1,1,2,
1285                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1286         gtk_table_attach (GTK_TABLE (mag_wh_table), mag_height, 1,2,1,2,
1287                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1288         gtk_table_attach (GTK_TABLE (mag_wh_table), mag_x_label, 0,1,2,3,
1289                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1290         gtk_table_attach (GTK_TABLE (mag_wh_table), mag_x, 1,2,2,3,
1291                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1292         gtk_table_attach (GTK_TABLE (mag_wh_table), mag_y_label, 0,1,3,4,
1293                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1294         gtk_table_attach (GTK_TABLE (mag_wh_table), mag_y, 1,2,3,4,
1295                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 5, 0);
1296
1297         mag_h_zoom_label = gtk_label_new ("Horizontal:");
1298         mag_h_zoom_adj = (GtkAdjustment *)gtk_adjustment_new(10.0, 1.0, 25.0, (gfloat)0.1, 1, 0);
1299         mag_h_zoom = gtk_spin_button_new (mag_h_zoom_adj, 0, 1);
1300
1301         mag_v_zoom_label = gtk_label_new ("Vertical:");
1302         mag_v_zoom_adj = (GtkAdjustment *)gtk_adjustment_new(10.0, 1.0, 25.0, (gfloat)0.1, 1, 0);
1303         mag_v_zoom = gtk_spin_button_new (mag_v_zoom_adj, 0, 1);
1304
1305         mag_zoom_same = gtk_check_button_new_with_label ("Keep them the same");
1306         mag_zoom_ratio = gtk_check_button_new_with_label("Preserve their ratio");
1307
1308         mag_zoom_table = gtk_table_new (4, 2, FALSE);
1309         gtk_table_attach (GTK_TABLE (mag_zoom_table), mag_h_zoom_label, 0,1,0,1,
1310                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
1311         gtk_table_attach (GTK_TABLE (mag_zoom_table), mag_h_zoom, 1,2,0,1,
1312                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
1313         gtk_table_attach (GTK_TABLE (mag_zoom_table), mag_v_zoom_label, 0,1,1,2,
1314                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
1315         gtk_table_attach (GTK_TABLE (mag_zoom_table), mag_v_zoom, 1,2,1,2,
1316                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
1317         gtk_table_attach (GTK_TABLE (mag_zoom_table), mag_zoom_same, 0,2,2,3,
1318                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
1319         gtk_table_attach (GTK_TABLE (mag_zoom_table), mag_zoom_ratio, 0,2,3,4,
1320                                 GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
1321
1322         mag_zoom_frame = gtk_frame_new ("Magnify zoom");
1323         gtk_container_add (GTK_CONTAINER (mag_zoom_frame), mag_zoom_table);
1324         gtk_container_set_border_width (GTK_CONTAINER (mag_zoom_frame), 3);
1325
1326         mag_box = gtk_vbox_new (FALSE, 0);
1327         gtk_box_pack_start (GTK_BOX (mag_box), mag_wh_table, TRUE, TRUE, 0);
1328         gtk_box_pack_start (GTK_BOX (mag_box), mag_zoom_frame, TRUE, TRUE, 0);
1329         mag_frame = gtk_frame_new ("Magnify");
1330         gtk_container_add (GTK_CONTAINER (mag_frame), mag_box);
1331
1332         g->magnify.widget.h_zoom = (GtkSpinButton * )mag_h_zoom;
1333         g->magnify.widget.v_zoom = (GtkSpinButton * )mag_v_zoom;
1334         OBJECT_SET_DATA(mag_h_zoom, "direction", GINT_TO_POINTER(0));
1335         OBJECT_SET_DATA(mag_v_zoom, "direction", GINT_TO_POINTER(1));
1336         OBJECT_SET_DATA(mag_zoom_same, "flag", (gpointer)MAGZOOMS_SAME);
1337         OBJECT_SET_DATA(mag_zoom_ratio, "flag", (gpointer)MAGZOOMS_SAME_RATIO);
1338
1339         SIGNAL_CONNECT(mag_width, "changed", callback_mag_width, g);
1340         SIGNAL_CONNECT(mag_height, "changed", callback_mag_height, g);
1341         SIGNAL_CONNECT(mag_x, "changed", callback_mag_x, g);
1342         SIGNAL_CONNECT(mag_y, "changed", callback_mag_y, g);
1343         SIGNAL_CONNECT(mag_h_zoom, "changed", callback_mag_zoom, g);
1344         SIGNAL_CONNECT(mag_v_zoom, "changed", callback_mag_zoom, g);
1345         SIGNAL_CONNECT(mag_zoom_same, "clicked", callback_mag_flags, g);
1346         SIGNAL_CONNECT(mag_zoom_ratio, "clicked", callback_mag_flags, g);
1347
1348         return mag_frame;
1349 }
1350
1351 static void callback_mag_width (GtkWidget *spin, gpointer data)
1352 {
1353         struct graph *g = (struct graph * )data;
1354
1355         g->magnify.width = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON(spin));
1356 }
1357
1358 static void callback_mag_height (GtkWidget *spin, gpointer data)
1359 {
1360         struct graph *g = (struct graph * )data;
1361
1362         g->magnify.height = gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
1363 }
1364
1365 static void callback_mag_x (GtkWidget *spin, gpointer data)
1366 {
1367         struct graph *g = (struct graph * )data;
1368
1369         g->magnify.offset.x=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
1370 }
1371
1372 static void callback_mag_y (GtkWidget *spin, gpointer data)
1373 {
1374         struct graph *g = (struct graph * )data;
1375
1376         g->magnify.offset.y=gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(spin));
1377 }
1378
1379 static void callback_mag_zoom (GtkWidget *spin, gpointer data)
1380 {
1381         struct graph *g = (struct graph * )data;
1382         double value;
1383         int direction;
1384         double *zoom_this, *zoom_other;
1385         GtkSpinButton *widget_this, *widget_other;
1386         double old_this;
1387
1388         if (g->magnify.flags & MAGZOOMS_IGNORE) {
1389                 printf ("refusing callback for %s zoom widget.\n", (GtkSpinButton * )spin==g->magnify.widget.h_zoom ? "horizontal" : "vertical");
1390                 g->magnify.flags &= ~MAGZOOMS_IGNORE;
1391                 return;
1392         }
1393         direction = (int)OBJECT_GET_DATA(spin, "direction");
1394         value = gtk_spin_button_get_value_as_float (GTK_SPIN_BUTTON (spin));
1395
1396         if (direction) {
1397                 zoom_this = &g->magnify.zoom.y;
1398                 zoom_other = &g->magnify.zoom.x;
1399                 widget_this = g->magnify.widget.v_zoom;
1400                 widget_other = g->magnify.widget.h_zoom;
1401         } else {
1402                 zoom_this = &g->magnify.zoom.x;
1403                 zoom_other = &g->magnify.zoom.y;
1404                 widget_this = g->magnify.widget.h_zoom;
1405                 widget_other = g->magnify.widget.v_zoom;
1406         }
1407
1408         old_this = *zoom_this;
1409         *zoom_this = value;
1410         if (g->magnify.flags & MAGZOOMS_SAME) {
1411                 *zoom_other = value;
1412                 /* g->magnify.flags |= MAGZOOMS_IGNORE; */
1413                 gtk_spin_button_set_value (widget_other, (gfloat) *zoom_other);
1414         } else if (g->magnify.flags & MAGZOOMS_SAME_RATIO) {
1415                 double old_other = *zoom_other;
1416                 *zoom_other *= value / old_this;
1417                 if (*zoom_other < 1.0) {
1418                         *zoom_other = 1.0;
1419                         *zoom_this = old_this * 1.0 / old_other;
1420                         /* g->magnify.flags |= MAGZOOMS_IGNORE; */
1421                         gtk_spin_button_set_value (widget_this, (gfloat) *zoom_this);
1422                 } else if (*zoom_other > 25.0) {
1423                         *zoom_other = 25.0;
1424                         *zoom_this = old_this * 25.0 / old_other;
1425                         /* g->magnify.flags |= MAGZOOMS_IGNORE; */
1426                         gtk_spin_button_set_value (widget_this, (gfloat) *zoom_this);
1427                 }
1428                 /* g->magnify.flags |= MAGZOOMS_IGNORE; */
1429                 gtk_spin_button_set_value (widget_other, (gfloat) *zoom_other);
1430         }
1431 }
1432
1433 static void callback_mag_flags (GtkWidget *toggle, gpointer data)
1434 {
1435         struct graph *g = (struct graph * )data;
1436         int flag = (int)OBJECT_GET_DATA(toggle, "flag");
1437
1438         if (GTK_TOGGLE_BUTTON (toggle)->active)
1439                 g->magnify.flags |= flag;
1440         else
1441                 g->magnify.flags &= ~flag;
1442 }
1443
1444 static GtkWidget *control_panel_create_zoomlock_group (struct graph *g)
1445 {
1446         GtkWidget *zoom_lock_h, *zoom_lock_v, *zoom_lock_none, *zoom_lock_box;
1447         GtkWidget *zoom_lock_frame;
1448
1449         zoom_lock_none = gtk_radio_button_new_with_label (NULL, "none");
1450         zoom_lock_h = gtk_radio_button_new_with_label (
1451                                         gtk_radio_button_group (GTK_RADIO_BUTTON (zoom_lock_none)),
1452                                         "horizontal");
1453         zoom_lock_v = gtk_radio_button_new_with_label (
1454                                         gtk_radio_button_group (GTK_RADIO_BUTTON (zoom_lock_none)),
1455                                         "vertical");
1456         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (zoom_lock_none), TRUE);
1457         zoom_lock_box = gtk_hbox_new (FALSE, 0);
1458         gtk_box_pack_start(GTK_BOX(zoom_lock_box), zoom_lock_none,
1459                            TRUE, TRUE, 0);
1460         gtk_box_pack_start(GTK_BOX(zoom_lock_box), zoom_lock_h, TRUE, TRUE, 0);
1461         gtk_box_pack_start(GTK_BOX(zoom_lock_box), zoom_lock_v, TRUE, TRUE, 0);
1462         zoom_lock_frame = gtk_frame_new ("Zoom lock:");
1463         gtk_container_add (GTK_CONTAINER (zoom_lock_frame), zoom_lock_box);
1464
1465         SIGNAL_CONNECT(zoom_lock_h, "toggled", callback_zoomlock_h, g);
1466         SIGNAL_CONNECT(zoom_lock_v, "toggled", callback_zoomlock_v, g);
1467
1468         return zoom_lock_frame;
1469 }
1470
1471 static void callback_zoomlock_h (GtkWidget *toggle, gpointer data)
1472 {
1473         struct graph *g = (struct graph * )data;
1474
1475         if (GTK_TOGGLE_BUTTON (toggle)->active)
1476                 g->zoom.flags |= ZOOM_HLOCK;
1477         else
1478                 g->zoom.flags &= ~ZOOM_HLOCK;
1479 }
1480
1481 static void callback_zoomlock_v (GtkWidget *toggle, gpointer data)
1482 {
1483         struct graph *g = (struct graph * )data;
1484
1485         if (GTK_TOGGLE_BUTTON (toggle)->active)
1486                 g->zoom.flags |= ZOOM_VLOCK;
1487         else
1488                 g->zoom.flags &= ~ZOOM_VLOCK;
1489 }
1490
1491 static GtkWidget *control_panel_create_cross_group (struct graph *g)
1492 {
1493         GtkWidget *on, *off, *box, *frame, *vbox, *label;
1494
1495         label = gtk_label_new ("Crosshairs:");
1496         off = gtk_radio_button_new_with_label (NULL, "off");
1497         on = gtk_radio_button_new_with_label (
1498                                 gtk_radio_button_group (GTK_RADIO_BUTTON (off)), "on");
1499         gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (off), TRUE);
1500         box = gtk_hbox_new (FALSE, 0);
1501         gtk_box_pack_start (GTK_BOX (box), label, FALSE, FALSE, 10);
1502         gtk_box_pack_start (GTK_BOX (box), off, FALSE, FALSE, 10);
1503         gtk_box_pack_start (GTK_BOX (box), on, FALSE, FALSE, 0);
1504         vbox = gtk_vbox_new (FALSE, 0);
1505         gtk_box_pack_start (GTK_BOX (vbox), box, FALSE, FALSE, 15);
1506         /* frame = gtk_frame_new ("Cross:"); */
1507         frame = gtk_frame_new (NULL);
1508         gtk_container_add (GTK_CONTAINER (frame), vbox);
1509
1510         SIGNAL_CONNECT(on, "toggled", callback_cross_on_off, g);
1511
1512         g->cross.on_toggle = (GtkToggleButton * )on;
1513         g->cross.off_toggle = (GtkToggleButton * )off;
1514
1515         return frame;
1516 }
1517
1518 static void callback_cross_on_off (GtkWidget *toggle, gpointer data)
1519 {
1520         struct graph *g = (struct graph * )data;
1521
1522         if (GTK_TOGGLE_BUTTON (toggle)->active) {
1523                 int x, y;
1524                 g->cross.draw = TRUE;
1525                 gdk_window_get_pointer (g->drawing_area->window, &x, &y, 0);
1526                 cross_draw (g, x, y);
1527         } else {
1528                 g->cross.draw = FALSE;
1529                 cross_erase (g);
1530         }
1531 }
1532
1533 static GtkWidget *control_panel_create_graph_type_group (struct graph *g)
1534 {
1535         GtkWidget *graph_tseqttrace, *graph_tseqstevens;
1536         GtkWidget *graph_tput, *graph_rtt, *graph_sep, *graph_init, *graph_box;
1537         GtkWidget *graph_frame;
1538
1539         graph_tput = gtk_radio_button_new_with_label (NULL, "Throughput");
1540         graph_tseqttrace = gtk_radio_button_new_with_label (
1541                                         gtk_radio_button_group (GTK_RADIO_BUTTON (graph_tput)),
1542                                         "Time/Sequence (tcptrace-style)");
1543         graph_tseqstevens = gtk_radio_button_new_with_label (
1544                                         gtk_radio_button_group (GTK_RADIO_BUTTON (graph_tput)),
1545                                         "Time/Sequence (Stevens'-style)");
1546         graph_rtt = gtk_radio_button_new_with_label (
1547                                         gtk_radio_button_group (GTK_RADIO_BUTTON (graph_tput)),
1548                                         "Round-trip Time");
1549         switch (g->type) {
1550         case GRAPH_TSEQ_STEVENS:
1551                 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(graph_tseqstevens),TRUE);
1552                 break;
1553         case GRAPH_TSEQ_TCPTRACE:
1554                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON(graph_tseqttrace),TRUE);
1555                 break;
1556         case GRAPH_THROUGHPUT:
1557                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (graph_tput), TRUE);
1558                 break;
1559         case GRAPH_RTT:
1560                 gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (graph_rtt), TRUE);
1561                 break;
1562         }
1563         graph_init = gtk_check_button_new_with_label ("Init on change");
1564         graph_sep = gtk_hseparator_new ();
1565         graph_box = gtk_vbox_new (FALSE, 0);
1566         gtk_box_pack_start (GTK_BOX (graph_box), graph_tseqttrace, TRUE, TRUE, 0);
1567         gtk_box_pack_start (GTK_BOX (graph_box), graph_tseqstevens, TRUE, TRUE, 0);
1568         gtk_box_pack_start (GTK_BOX (graph_box), graph_tput, TRUE, TRUE, 0);
1569         gtk_box_pack_start (GTK_BOX (graph_box), graph_rtt, TRUE, TRUE, 0);
1570         gtk_box_pack_start (GTK_BOX (graph_box), graph_sep, TRUE, TRUE, 0);
1571         gtk_box_pack_start (GTK_BOX (graph_box), graph_init, TRUE, TRUE, 0);
1572         graph_frame = gtk_frame_new ("Graph type:");
1573         gtk_container_add (GTK_CONTAINER (graph_frame), graph_box);
1574
1575         OBJECT_SET_DATA(graph_tseqstevens, "new-graph-type",
1576                         GINT_TO_POINTER(0));
1577         OBJECT_SET_DATA(graph_tseqttrace, "new-graph-type", GINT_TO_POINTER(1));
1578         OBJECT_SET_DATA(graph_tput, "new-graph-type", GINT_TO_POINTER(2));
1579         OBJECT_SET_DATA(graph_rtt, "new-graph-type", GINT_TO_POINTER(3));
1580
1581         SIGNAL_CONNECT(graph_tseqttrace, "toggled", callback_graph_type, g);
1582         SIGNAL_CONNECT(graph_tseqstevens, "toggled", callback_graph_type, g);
1583         SIGNAL_CONNECT(graph_tput, "toggled", callback_graph_type, g);
1584         SIGNAL_CONNECT(graph_rtt, "toggled", callback_graph_type, g);
1585         SIGNAL_CONNECT(graph_init, "toggled", callback_graph_init_on_typechg,
1586                        g);
1587
1588         return graph_frame;
1589 }
1590
1591 static void callback_graph_type (GtkWidget *toggle, gpointer data)
1592 {
1593         int old_type, new_type;
1594         struct graph *g = (struct graph * )data;
1595
1596         new_type = (int)OBJECT_GET_DATA(toggle,"new-graph-type");
1597
1598         if (!GTK_TOGGLE_BUTTON (toggle)->active)
1599                 return;
1600
1601         old_type = g->type;
1602         g->type = new_type;
1603
1604         graph_element_lists_free (g);
1605         graph_element_lists_initialize (g);
1606
1607         if (old_type == GRAPH_THROUGHPUT || new_type == GRAPH_THROUGHPUT) {
1608                 /* throughput graph uses differently constructed segment list so we
1609                  * need to recreate it */
1610                 graph_segment_list_free (g);
1611                 graph_segment_list_get (g);
1612         }
1613
1614         if (g->flags & GRAPH_INIT_ON_TYPE_CHANGE) {
1615                 g->geom.width = g->wp.width;
1616                 g->geom.height = g->wp.height;
1617                 g->geom.x = g->wp.x;
1618                 g->geom.y = g->wp.y;
1619         }
1620         g->x_axis->min = g->y_axis->min = 0;
1621         gtk_toggle_button_set_active (g->gui.time_orig_conn, TRUE);
1622         gtk_toggle_button_set_active (g->gui.seq_orig_isn, TRUE);
1623         graph_init_sequence (g);
1624 }
1625
1626 static void callback_graph_init_on_typechg (GtkWidget *toggle _U_, gpointer data)
1627 {
1628         ((struct graph * )data)->flags ^= GRAPH_INIT_ON_TYPE_CHANGE;
1629 }
1630
1631 static struct graph *graph_new (void)
1632 {
1633         struct graph *g;
1634
1635         g = (struct graph * )calloc (1, sizeof (struct graph));
1636         graph_element_lists_initialize (g);
1637
1638         g->x_axis = (struct axis * )calloc (1, sizeof (struct axis));
1639         g->y_axis = (struct axis * )calloc (1, sizeof (struct axis));
1640         g->x_axis->g = g;
1641         g->x_axis->flags = 0;
1642         g->x_axis->flags |= AXIS_ORIENTATION;
1643         g->x_axis->s.x = g->x_axis->s.y = 0;
1644         g->x_axis->s.height = HAXIS_INIT_HEIGHT;
1645         g->x_axis->p.x = VAXIS_INIT_WIDTH;
1646         g->x_axis->p.height = HAXIS_INIT_HEIGHT;
1647         g->y_axis->g = g;
1648         g->y_axis->flags = 0;
1649         g->y_axis->flags &= ~AXIS_ORIENTATION;
1650         g->y_axis->p.x = g->y_axis->p.y = 0;
1651         g->y_axis->p.width = VAXIS_INIT_WIDTH;
1652         g->y_axis->s.x = 0;
1653         g->y_axis->s.y = TITLEBAR_HEIGHT;
1654         g->y_axis->s.width = VAXIS_INIT_WIDTH;
1655
1656         return g;
1657 }
1658
1659 static void graph_initialize_values (struct graph *g)
1660 {
1661         g->geom.width = g->wp.width = 750;
1662         g->geom.height = g->wp.height = 550;
1663         g->geom.x = g->wp.x = VAXIS_INIT_WIDTH;
1664         g->geom.y = g->wp.y = TITLEBAR_HEIGHT;
1665         g->flags = 0;
1666         /* g->zoom.x = g->zoom.y = 1.0; */
1667         g->zoom.step_x = g->zoom.step_y = 1.2;
1668         g->zoom.flags = 0;
1669         g->cross.draw = g->cross.erase_needed = 0;
1670         g->grab.grabbed = 0;
1671         g->magnify.active = 0;
1672         g->magnify.offset.x = g->magnify.offset.y = 0;
1673         g->magnify.width = g->magnify.height = 250;
1674         g->magnify.zoom.x = g->magnify.zoom.y = 10.0;
1675         g->magnify.flags = 0;
1676 }
1677
1678 static void graph_put (struct graph *graph)
1679 {
1680         struct graph *g;
1681         if (graphs) {
1682                 for (g=graphs; g->next; g=g->next);
1683                 g->next = graph;
1684         } else
1685                 graphs = graph;
1686 }
1687
1688 static void graph_init_sequence (struct graph *g)
1689 {
1690         debug(DBS_FENTRY) puts ("graph_init_sequence()");
1691
1692         graph_type_dependent_initialize (g);
1693         g->zoom.initial.x = g->zoom.x;
1694         g->zoom.initial.y = g->zoom.y;
1695         graph_element_lists_make (g);
1696         g->x_axis->s.width = g->wp.width;
1697         g->x_axis->p.width = g->x_axis->s.width + RMARGIN_WIDTH;
1698         g->x_axis->p.y = TITLEBAR_HEIGHT + g->wp.height;
1699         g->x_axis->s.height = g->x_axis->p.height = HAXIS_INIT_HEIGHT;
1700         g->y_axis->s.height = g->wp.height;
1701         g->y_axis->p.height = g->wp.height + TITLEBAR_HEIGHT;
1702         graph_pixmaps_create (g);
1703         axis_pixmaps_create (g->y_axis);
1704         axis_pixmaps_create (g->x_axis);
1705         graph_title_pixmap_create (g);
1706         graph_title_pixmap_draw (g);
1707         graph_title_pixmap_display (g);
1708         graph_display (g);
1709         axis_display (g->y_axis);
1710         axis_display (g->x_axis);
1711 }
1712
1713 static void graph_type_dependent_initialize (struct graph *g)
1714 {
1715         switch (g->type) {
1716         case GRAPH_TSEQ_STEVENS:
1717         case GRAPH_TSEQ_TCPTRACE:
1718                 tseq_stevens_initialize (g);
1719                 break;
1720         case GRAPH_THROUGHPUT:
1721                 tput_initialize (g);
1722                 break;
1723         case GRAPH_RTT:
1724                 rtt_initialize (g);
1725                 break;
1726         default:
1727                 break;
1728         }
1729 }
1730
1731 static void graph_destroy (struct graph *g)
1732 {
1733         struct graph *gtmp;
1734         struct graph *p=NULL;
1735         /* struct graph *tmp; */
1736
1737         debug(DBS_FENTRY) puts ("graph_destroy()");
1738
1739         for (gtmp=graphs; gtmp; p=gtmp, gtmp=gtmp->next)
1740                 if (gtmp == g)
1741                         break;
1742
1743         axis_destroy (g->x_axis);
1744         axis_destroy (g->y_axis);
1745         /* gtk_widget_destroy (g->drawing_area); */
1746         gtk_widget_destroy (g->gui.control_panel);
1747         gtk_widget_destroy (g->toplevel);
1748         /* gtk_widget_destroy (g->text); */
1749         gdk_gc_unref (g->fg_gc);
1750         gdk_gc_unref (g->bg_gc);
1751 #if GTK_MAJOR_VERSION < 2
1752         gdk_font_unref (g->font);
1753 #endif
1754         gdk_pixmap_unref (g->pixmap[0]);
1755         gdk_pixmap_unref (g->pixmap[1]);
1756         free (g->x_axis);
1757         free (g->y_axis);
1758         free (g->title);
1759         graph_segment_list_free (g);
1760         graph_element_lists_free (g);
1761 #if 0
1762         for (tmp=graphs; tmp; tmp=tmp->next)
1763                 printf ("%p next: %p\n", tmp, tmp->next);
1764         printf ("p=%p, g=%p, p->next=%p, g->next=%p\n",
1765                                                                         p, g, p ? p->next : NULL, g->next);
1766 #endif
1767         if (g==graphs)
1768                 graphs = g->next;
1769         else
1770                 p->next = g->next;
1771         free (g);
1772 #if 0
1773         for (tmp=graphs; tmp; tmp=tmp->next)
1774                 printf ("%p next: %p\n", tmp, tmp->next);
1775 #endif
1776 }
1777
1778 /* here we collect all the external data we will ever need */
1779 static void graph_segment_list_get (struct graph *g)
1780 {
1781         frame_data *ptr;
1782         union wtap_pseudo_header pseudo_header;
1783         char pd[WTAP_MAX_PACKET_SIZE];
1784         struct segment *segment=NULL, *last=NULL;
1785         struct segment current;
1786         int condition;
1787         int err;
1788         gchar *err_info;
1789
1790         debug(DBS_FENTRY) puts ("graph_segment_list_get()");
1791         get_headers (cfile.current_frame, cfile.pd, &current);
1792         if (g->type == GRAPH_THROUGHPUT)
1793                 condition = COMPARE_CURR_DIR;
1794         else
1795                 condition = COMPARE_ANY_DIR;
1796
1797         for (ptr=cfile.plist; ptr; ptr=ptr->next) {
1798                 if (!wtap_seek_read (cfile.wth, ptr->file_off, &pseudo_header,
1799                                      pd, ptr->cap_len, &err, &err_info)) {
1800                         simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
1801                                       cf_read_error_message(err, err_info),
1802                                       cfile.filename);
1803                         break;
1804                 }
1805                 if (!segment)
1806                         segment = (struct segment * )malloc (sizeof (struct segment));
1807                         if (!segment)
1808                                 perror ("malloc failed");
1809                 if (!get_headers (ptr, pd, segment))
1810                         continue;       /* not TCP over IP over Ethernet II */
1811                 if (compare_headers (&current, segment, condition)) {
1812                         segment->next = NULL;
1813                         segment->num = ptr->num;
1814                         segment->rel_secs = ptr->rel_secs;
1815                         segment->rel_usecs = ptr->rel_usecs;
1816                         segment->abs_secs = ptr->abs_secs;
1817                         segment->abs_usecs = ptr->abs_usecs;
1818                         segment->data = g_ntohs (segment->iphdr.tot_len) -
1819                                                         4*IHL(&(segment->iphdr)) - 4*DOFF(segment->tcphdr);
1820                         if (g->segments) {
1821                                 last->next = segment;
1822                         } else {
1823                                 g->segments = segment;
1824                         }
1825                         last = segment;
1826                         if (ptr==cfile.current_frame)
1827                                 g->current = segment;
1828                 }
1829                 segment = NULL;
1830         }
1831 }
1832
1833 static int get_headers (frame_data *fd, char *pd, struct segment *hdrs)
1834 {
1835         struct ether_header *e;
1836         struct ppp_header   *p;
1837         struct vlan_802_1_q *vlan;
1838         void *ip;
1839         void *tcp;
1840
1841         /*
1842          * XXX - on Alpha, even fetching one-byte fields from structures
1843          * pointed to by unaligned pointers may be risky, as, unless
1844          * the BWX instructions are being used, a one-byte load is done
1845          * by loading the word containing the byte and then extracting
1846          * the byte.
1847          *
1848          * This means that the references to "p->ppp_type" and
1849          * "((struct iphdr *)ip)->protocol" may turn into a load of
1850          * an unaligned word.
1851          */
1852         switch (fd->lnk_t) {
1853
1854         case WTAP_ENCAP_ETHERNET:
1855                 /* It's Ethernet */
1856                 e = (struct ether_header *)pd;
1857                 switch (pntohs (&e->ether_type))
1858                 {
1859                         case ETHERTYPE_IP:
1860                                 ip = e + 1;
1861                                 break;
1862
1863                         case ETHERTYPE_VLAN:
1864                                 /*
1865                                  * This code is awful but no more than the
1866                                  * rest of this file!!
1867                                  *
1868                                  * This really needs to be converted to
1869                                  * work as a TCP tap, so that the
1870                                  * regular dissectors take care of
1871                                  * finding the TCP header, rather than
1872                                  * doing our own *ad hoc* header
1873                                  * parsing.
1874                                  */ 
1875                                 vlan = (struct vlan_802_1_q *)(e + 1);
1876                                 if (ETHERTYPE_IP != pntohs(&vlan->type))
1877                                         return FALSE;
1878                                 ip = vlan + 1;
1879                                 break;
1880
1881                         default:
1882                                 return FALSE;
1883                 }
1884                 break;
1885
1886         case WTAP_ENCAP_PPP:
1887         case WTAP_ENCAP_PPP_WITH_PHDR:
1888                 /* It's PPP */
1889                 p = (struct ppp_header *)pd;
1890                 if (p->ppp_type != PPP_IP)
1891                         return FALSE;   /* not IP */
1892                 ip = p + 1;
1893                 break;
1894
1895         case WTAP_ENCAP_RAW_IP:
1896                 /* Raw IP */
1897                 ip = pd;
1898                 break;
1899
1900         default:
1901                 /* Those are the only encapsulation types we handle */
1902                 return FALSE;
1903         }
1904         if (((struct iphdr *)ip)->protocol != IP_PROTO_TCP) {
1905                 /* printf ("transport protocol not TCP: %#1x\n", ip->protocol); */
1906                 return FALSE;
1907         }
1908         tcp = (struct tcphdr *)((guint8 *)ip + 4*IHL((struct iphdr *)ip));
1909
1910         memcpy(&hdrs->iphdr, ip, sizeof (struct iphdr));
1911         memcpy(&hdrs->tcphdr, tcp, sizeof (struct tcphdr));
1912         return TRUE;
1913 }
1914
1915 static int compare_headers (struct segment *h1, struct segment *h2, int dir)
1916 {
1917         if (dir == COMPARE_CURR_DIR)
1918                 return h1->iphdr.saddr == h2->iphdr.saddr &&
1919                            h1->iphdr.daddr == h2->iphdr.daddr &&
1920                            h1->tcphdr.source == h2->tcphdr.source &&
1921                            h1->tcphdr.dest == h2->tcphdr.dest;
1922         else
1923                 return (h1->iphdr.saddr == h2->iphdr.saddr &&
1924                            h1->iphdr.daddr == h2->iphdr.daddr &&
1925                            h1->tcphdr.source == h2->tcphdr.source &&
1926                            h1->tcphdr.dest == h2->tcphdr.dest) ||
1927                            (h1->iphdr.saddr == h2->iphdr.daddr &&
1928                            h1->iphdr.daddr == h2->iphdr.saddr &&
1929                            h1->tcphdr.source == h2->tcphdr.dest &&
1930                            h1->tcphdr.dest == h2->tcphdr.source);
1931 }
1932
1933 static void graph_segment_list_free (struct graph *g)
1934 {
1935         struct segment *segment;
1936
1937         while (g->segments) {
1938                 segment = g->segments->next;
1939                 free (g->segments);
1940                 g->segments = segment;
1941         }
1942         g->segments = NULL;
1943 }
1944
1945 static void graph_element_lists_initialize (struct graph *g)
1946 {
1947         g->elists = (struct element_list *)calloc (1, sizeof (struct element_list));
1948 }
1949
1950 static void graph_element_lists_make (struct graph *g)
1951 {
1952         debug(DBS_FENTRY) puts ("graph_element_lists_make()");
1953
1954         switch (g->type) {
1955         case GRAPH_TSEQ_STEVENS:
1956                 tseq_stevens_make_elmtlist (g);
1957                 break;
1958         case GRAPH_TSEQ_TCPTRACE:
1959                 tseq_tcptrace_make_elmtlist (g);
1960                 break;
1961         case GRAPH_THROUGHPUT:
1962                 tput_make_elmtlist (g);
1963                 break;
1964         case GRAPH_RTT:
1965                 rtt_make_elmtlist (g);
1966                 break;
1967         default:
1968                 printf ("graph_element_lists_make: unknown graph type: %d\n", g->type);
1969                 break;
1970         }
1971 }
1972
1973 static void graph_element_lists_free (struct graph *g)
1974 {
1975         struct element_list *list, *next_list;
1976
1977 #if 0
1978         for (list=g->elists; list; list=list->next)
1979                 free (list->elements);
1980         while (g->elists->next) {
1981                 list = g->elists->next->next;
1982                 free (g->elists->next);
1983                 g->elists->next = list;
1984         }
1985 #endif
1986
1987         for (list=g->elists; list; list=next_list) {
1988                 free (list->elements);
1989                 next_list = list->next;
1990                 free (list);
1991         }
1992         g->elists = NULL;       /* just to make debugging easier */
1993 }
1994
1995 static void graph_title_pixmap_create (struct graph *g)
1996 {
1997         if (g->title_pixmap)
1998                 gdk_pixmap_unref (g->title_pixmap);
1999
2000         g->title_pixmap = gdk_pixmap_new (g->drawing_area->window,
2001                                                         g->x_axis->p.width, g->wp.y, -1);
2002 }
2003
2004 static void graph_title_pixmap_draw (struct graph *g)
2005 {
2006         int i;
2007
2008         gdk_draw_rectangle(g->title_pixmap, g->bg_gc, TRUE, 0, 0,
2009                            g->x_axis->p.width, g->wp.y);
2010         for (i=0; g->title[i]; i++) {
2011                 gint w, h;
2012 #if GTK_MAJOR_VERSION < 2
2013                 w = gdk_string_width(g->font, g->title[i]);
2014                 h = gdk_string_height(g->font, g->title[i]);
2015                 gdk_draw_string(g->title_pixmap, g->font, g->fg_gc,
2016                                 g->wp.width/2 - w/2, 20+h + i*(h+3),
2017                                 g->title[i]);
2018 #else
2019                 PangoLayout *layout;
2020                 layout = gtk_widget_create_pango_layout(g->drawing_area,
2021                                                         g->title[i]);
2022                 pango_layout_get_pixel_size(layout, &w, &h);
2023                 gdk_draw_layout(g->title_pixmap, g->fg_gc,
2024                                 g->wp.width/2 - w/2, 20 + i*(h+3), layout);
2025                 g_object_unref(G_OBJECT(layout));
2026 #endif
2027         }
2028 }
2029
2030 static void graph_title_pixmap_display (struct graph *g)
2031 {
2032         gdk_draw_pixmap (g->drawing_area->window, g->fg_gc, g->title_pixmap,
2033                          0, 0, g->wp.x, 0, g->x_axis->p.width, g->wp.y);
2034 }
2035
2036 static void graph_pixmaps_create (struct graph *g)
2037 {
2038         debug(DBS_FENTRY) puts ("graph_pixmaps_create()");
2039
2040         if (g->pixmap[0])
2041                 gdk_pixmap_unref (g->pixmap[0]);
2042         if (g->pixmap[1])
2043                 gdk_pixmap_unref (g->pixmap[1]);
2044
2045         g->pixmap[0] = gdk_pixmap_new (g->drawing_area->window,
2046                                                                         g->wp.width, g->wp.height, -1);
2047         g->pixmap[1] = gdk_pixmap_new (g->drawing_area->window,
2048                                                                         g->wp.width, g->wp.height, -1);
2049
2050         g->displayed = 0;
2051 }
2052
2053 static void graph_display (struct graph *g)
2054 {
2055         graph_pixmap_draw (g);
2056         graph_pixmaps_switch (g);
2057         graph_pixmap_display (g);
2058 }
2059
2060 static void graph_pixmap_display (struct graph *g)
2061 {
2062     gdk_draw_pixmap (g->drawing_area->window, g->fg_gc,
2063                                         g->pixmap[g->displayed], 0, 0, g->wp.x, g->wp.y,
2064                                         g->wp.width, g->wp.height);
2065     if (g->cross.erase_needed) {
2066        cross_xor(g, g->cross.x, g->cross.y);
2067     }
2068 }
2069
2070 static void graph_pixmaps_switch (struct graph *g)
2071 {
2072         g->displayed = 1 ^ g->displayed;
2073 }
2074
2075 static void graph_pixmap_draw (struct graph *g)
2076 {
2077         struct element_list *list;
2078         struct element *e;
2079         int not_disp;
2080
2081         debug(DBS_FENTRY) puts ("graph_display()");
2082         not_disp = 1 ^ g->displayed;
2083
2084         gdk_draw_rectangle (g->pixmap[not_disp], g->bg_gc, TRUE,
2085                                                         0, 0, g->wp.width, g->wp.height);
2086
2087         for (list=g->elists; list; list=list->next)
2088                 for (e=list->elements; e->type != ELMT_NONE; e++) {
2089                         switch (e->type) {
2090                         case ELMT_RECT:
2091                                 break;
2092                         case ELMT_LINE:
2093                                 draw_element_line (g, e);
2094                                 break;
2095                         case ELMT_ARC:
2096                                 draw_element_arc (g, e);
2097                                 break;
2098                         default:
2099                                 break;
2100                         }
2101                 }
2102 }
2103
2104 static void draw_element_line (struct graph *g, struct element *e)
2105 {
2106         int x1, x2, y1, y2;
2107
2108         debug(DBS_GRAPH_DRAWING) printf ("line element: (%.2f,%.2f)->(%.2f,%.2f), "
2109                                 "seg %d ... ", e->p.line.dim.x1, e->p.line.dim.y1,
2110                                 e->p.line.dim.x2, e->p.line.dim.y2, e->parent->num);
2111         x1 = (int )rint (e->p.line.dim.x1 + g->geom.x - g->wp.x);
2112         x2 = (int )rint (e->p.line.dim.x2 + g->geom.x - g->wp.x);
2113         y1 = (int )rint ((g->geom.height-1-e->p.line.dim.y1) + g->geom.y-g->wp.y);
2114         y2 = (int )rint ((g->geom.height-1-e->p.line.dim.y2) + g->geom.y-g->wp.y);
2115         if (x1 > x2) {
2116                 int tmp=x2;
2117                 x2=x1;
2118                 x1=tmp;
2119         }
2120         if (y1 > y2) {
2121                 int tmp=y2;
2122                 y2=y1;
2123                 y1=tmp;
2124         }
2125         if ((x1<0 && x2<0) || (x1>=g->wp.width && x2>=g->wp.width) ||
2126                                 (y1<0 && y2<0) || (y1>=g->wp.height && y2>=g->wp.height)) {
2127                 debug(DBS_GRAPH_DRAWING) printf (" refusing: (%d,%d)->(%d,%d)\n",
2128                                                                         x1, y1, x2, y2);
2129                 return;
2130         }
2131         if (x2 > g->wp.width-1)
2132                 x2 = g->wp.width-1;
2133         if (x1 < 0)
2134                 x1 = 0;
2135         if (y2 > g->wp.height-1)
2136                 y2 = g->wp.height-1;
2137         if (y1 < 0)
2138                 y1 = 0;
2139         debug(DBS_GRAPH_DRAWING) printf ("line: (%d,%d)->(%d,%d)\n", x1, y1, x2,y2);
2140         gdk_draw_line (g->pixmap[1^g->displayed], e->gc, x1, y1, x2, y2);
2141 }
2142
2143 static void draw_element_arc (struct graph *g, struct element *e)
2144 {
2145         int x1, x2, y1, y2;
2146
2147         x1 = (int )rint (e->p.arc.dim.x + g->geom.x - g->wp.x);
2148         x2 = (int )e->p.arc.dim.width;
2149         y1 = (int )rint (g->geom.height-1 - e->p.arc.dim.y + g->geom.y - g->wp.y);
2150         y2 = (int )e->p.arc.dim.height;
2151         if (x1<-x2 || x1>=g->wp.width || y1<-y2 || y1>=g->wp.height)
2152                 return;
2153         debug(DBS_GRAPH_DRAWING) printf ("arc: (%d,%d)->(%d,%d)\n", x1, y1, x2, y2);
2154         gdk_draw_arc (g->pixmap[1^g->displayed], e->gc, e->p.arc.filled, x1,
2155                                         y1, x2, y2, e->p.arc.angle1, e->p.arc.angle2);
2156 }
2157
2158 static void axis_pixmaps_create (struct axis *axis)
2159 {
2160         debug(DBS_FENTRY) puts ("axis_pixmaps_create()");
2161         if (axis->pixmap[0])
2162                 gdk_pixmap_unref (axis->pixmap[0]);
2163         if (axis->pixmap[1])
2164                 gdk_pixmap_unref (axis->pixmap[1]);
2165
2166         axis->pixmap[0] = gdk_pixmap_new (axis->drawing_area->window,
2167                                                         axis->p.width, axis->p.height, -1);
2168         axis->pixmap[1] = gdk_pixmap_new (axis->drawing_area->window,
2169                                                         axis->p.width, axis->p.height, -1);
2170
2171         axis->displayed = 0;
2172 }
2173
2174 static void axis_destroy (struct axis *axis)
2175 {
2176         gdk_pixmap_unref (axis->pixmap[0]);
2177         gdk_pixmap_unref (axis->pixmap[1]);
2178         free (axis->label);
2179 }
2180
2181 static void axis_display (struct axis *axis)
2182 {
2183         if (axis->flags & AXIS_ORIENTATION)
2184                 h_axis_pixmap_draw (axis);
2185         else
2186                 v_axis_pixmap_draw (axis);
2187         axis_pixmaps_switch (axis);
2188         axis_pixmap_display (axis);
2189 }
2190
2191 static void v_axis_pixmap_draw (struct axis *axis)
2192 {
2193         struct graph *g = axis->g;
2194         int i;
2195         double major_tick;
2196         int not_disp, rdigits, offset, imin, imax;
2197         double bottom, top, j, fl, corr;
2198 #if GTK_MAJOR_VERSION >= 2
2199         PangoLayout *layout;
2200 #endif
2201
2202         debug(DBS_FENTRY) puts ("v_axis_pixmap_draw()");
2203         bottom = (g->geom.height - (g->wp.height + g->wp.y + (-g->geom.y))) /
2204                                         (double )g->geom.height * g->bounds.height;
2205         bottom += axis->min;
2206         top = (g->geom.height - (g->wp.y + (-g->geom.y))) /
2207                                         (double )g->geom.height * g->bounds.height;
2208         top += axis->min;
2209         axis_compute_ticks (axis, bottom, top, AXIS_VERTICAL);
2210
2211         j = axis->major - floor (axis->major);
2212         for (rdigits=0; rdigits<=6; rdigits++) {
2213                 j *= 10;
2214                 if (j<=0.000001)
2215                         break;
2216                 j = j - floor (j);
2217         }
2218
2219         not_disp = 1 ^ axis->displayed;
2220         gdk_draw_rectangle (axis->pixmap[not_disp], g->bg_gc, TRUE, 0, 0,
2221                                         axis->p.width, axis->p.height);
2222         /* axis */
2223         gdk_draw_line (axis->pixmap[not_disp], g->fg_gc, axis->p.width - 1,
2224                         (gint) ((axis->p.height-axis->s.height)/2.0), axis->s.width - 1,
2225                         axis->p.height);
2226
2227         offset = g->wp.y + (-g->geom.y);
2228         fl = floor (axis->min / axis->major) * axis->major;
2229         corr = rint ((axis->min - fl) * g->zoom.y);
2230
2231         /* major ticks */
2232         major_tick = axis->major * g->zoom.y;
2233         imin = (int) ((g->geom.height - offset + corr - g->wp.height) / major_tick + 1);
2234         imax = (int) ((g->geom.height - offset + corr) / major_tick);
2235         for (i=imin; i <= imax; i++) {
2236                 gint w, h;
2237                 char desc[32];
2238                 int y = (int) (g->geom.height-1 - (int )rint (i * major_tick) -
2239                                                 offset + corr + axis->s.y);
2240
2241                 debug(DBS_AXES_DRAWING) printf("%f @ %d\n",
2242                                                i*axis->major + fl, y);
2243                 if (y < 0 || y > axis->p.height)
2244                         continue;
2245                 gdk_draw_line (axis->pixmap[not_disp], g->fg_gc,
2246                                axis->s.width - 15, y, axis->s.width - 1, y);
2247                 snprintf (desc, 32, "%.*f", rdigits, i*axis->major + fl);
2248 #if GTK_MAJOR_VERSION < 2
2249                 w = gdk_string_width(g->font, desc);
2250                 h = gdk_string_height(g->font, desc);
2251                 gdk_draw_string(axis->pixmap[not_disp], g->font, g->fg_gc,
2252                                 axis->s.width-15-4-w, y + h/2, desc);
2253 #else
2254                 layout = gtk_widget_create_pango_layout(g->drawing_area, desc);
2255                 pango_layout_get_pixel_size(layout, &w, &h);
2256                 gdk_draw_layout(axis->pixmap[not_disp], g->fg_gc,
2257                                 axis->s.width-14-4-w, y - h/2, layout);
2258                 g_object_unref(G_OBJECT(layout));
2259 #endif
2260         }
2261         /* minor ticks */
2262         if (axis->minor) {
2263                 double minor_tick = axis->minor * g->zoom.y;
2264                 imin = (int) ((g->geom.height - offset + corr - g->wp.height)/minor_tick + 1);
2265                 imax = (int) ((g->geom.height - offset + corr) / minor_tick);
2266                 for (i=imin; i <= imax; i++) {
2267                         int y = (int) (g->geom.height-1 - (int )rint (i*minor_tick) -
2268                                                         offset + corr + axis->s.y);
2269
2270                         debug (DBS_AXES_DRAWING) printf ("%f @ %d\n", i*axis->minor+fl, y);
2271                         if (y > 0 && y < axis->p.height)
2272                                 gdk_draw_line (axis->pixmap[not_disp], g->fg_gc,
2273                                                axis->s.width - 8, y,
2274                                                axis->s.width - 1, y);
2275                 }
2276         }
2277         for (i=0; axis->label[i]; i++) {
2278                 gint w, h;
2279 #if GTK_MAJOR_VERSION < 2
2280                 w = gdk_string_width (g->font, axis->label[i]);
2281                 h = gdk_string_height (g->font, axis->label[i]);
2282                 gdk_draw_string(axis->pixmap[not_disp], g->font, g->fg_gc,
2283                                 (axis->p.width - w)/2 ,
2284                                 TITLEBAR_HEIGHT-15 - i*(h+3), axis->label[i]);
2285 #else
2286                 layout = gtk_widget_create_pango_layout(g->drawing_area,
2287                                                         axis->label[i]);
2288                 pango_layout_get_pixel_size(layout, &w, &h);
2289                 gdk_draw_layout(axis->pixmap[not_disp], g->fg_gc,
2290                                 (axis->p.width - w)/2,
2291                                 TITLEBAR_HEIGHT-10 - i*(h+3) - h,
2292                                 layout);
2293                 g_object_unref(G_OBJECT(layout));
2294 #endif
2295         }
2296 }
2297
2298 static void h_axis_pixmap_draw (struct axis *axis)
2299 {
2300         struct graph *g = axis->g;
2301         int i;
2302         double major_tick, minor_tick;
2303         int not_disp, rdigits, offset, imin, imax;
2304         double left, right, j, fl, corr;
2305 #if GTK_MAJOR_VERSION >= 2
2306         PangoLayout *layout;
2307 #endif
2308
2309         debug(DBS_FENTRY) puts ("h_axis_pixmap_draw()");
2310         left = (g->wp.x-g->geom.x) /
2311                                         (double )g->geom.width * g->bounds.width;
2312         left += axis->min;
2313         right = (g->wp.x-g->geom.x+g->wp.width) /
2314                                         (double )g->geom.width * g->bounds.width;
2315         right += axis->min;
2316         axis_compute_ticks (axis, left, right, AXIS_HORIZONTAL);
2317
2318         j = axis->major - floor (axis->major);
2319         for (rdigits=0; rdigits<=6; rdigits++) {
2320                 j *= 10;
2321                 if (j<=0.000001)
2322                         break;
2323                 j = j - floor (j);
2324         }
2325
2326         not_disp = 1 ^ axis->displayed;
2327         gdk_draw_rectangle (axis->pixmap[not_disp], g->bg_gc, TRUE, 0, 0,
2328                                         axis->p.width, axis->p.height);
2329         /* axis */
2330         gdk_draw_line (axis->pixmap[not_disp], g->fg_gc, 0, 0,
2331                                                 (gint) (axis->s.width + (axis->p.width-axis->s.width)/2.0), 0);
2332         offset = g->wp.x - g->geom.x;
2333
2334         fl = floor (axis->min / axis->major) * axis->major;
2335         corr = rint ((axis->min - fl) * g->zoom.x);
2336
2337         /* major ticks */
2338         major_tick = axis->major*g->zoom.x;
2339         imin = (int) ((offset + corr) / major_tick + 1);
2340         imax = (int) ((offset + corr + axis->s.width) / major_tick);
2341         for (i=imin; i <= imax; i++) {
2342                 char desc[32];
2343                 int w, h;
2344                 int x = (int ) (rint (i * major_tick) - offset - corr);
2345
2346                 /* printf ("%f @ %d\n", i*axis->major + fl, x); */
2347                 if (x < 0 || x > axis->s.width)
2348                         continue;
2349                 gdk_draw_line (axis->pixmap[not_disp], g->fg_gc, x, 0, x, 15);
2350                 snprintf (desc, 32, "%.*f", rdigits, i*axis->major + fl);
2351 #if GTK_MAJOR_VERSION < 2
2352                 w = gdk_string_width (g->font, desc);
2353                 h = gdk_string_height (g->font, desc);
2354                 gdk_draw_string (axis->pixmap[not_disp], g->font, g->fg_gc,
2355                                  x - w/2, 15+h+4, desc);
2356 #else
2357                 layout = gtk_widget_create_pango_layout(g->drawing_area, desc);
2358                 pango_layout_get_pixel_size(layout, &w, &h);
2359                 gdk_draw_layout(axis->pixmap[not_disp], g->fg_gc,
2360                                 x - w/2, 15+4, layout);
2361                 g_object_unref(G_OBJECT(layout));
2362 #endif
2363         }
2364         if (axis->minor > 0) {
2365                 /* minor ticks */
2366                 minor_tick = axis->minor*g->zoom.x;
2367                 imin = (int) ((offset + corr) / minor_tick + 1);
2368                 imax = (int) ((offset + corr + g->wp.width) / minor_tick);
2369                 for (i=imin; i <= imax; i++) {
2370                         int x = (int) (rint (i * minor_tick) - offset - corr);
2371                         if (x > 0 && x < axis->s.width)
2372                                 gdk_draw_line (axis->pixmap[not_disp], g->fg_gc, x, 0, x, 8);
2373                 }
2374         }
2375         for (i=0; axis->label[i]; i++) {
2376                 gint w, h;
2377 #if GTK_MAJOR_VERSION < 2
2378                 w = gdk_string_width (g->font, axis->label[i]);
2379                 h = gdk_string_height (g->font, axis->label[i]);
2380                 gdk_draw_string(axis->pixmap[not_disp], g->font, g->fg_gc,
2381                                 axis->s.width - w - 50, 15+2*h+15 + i*(h+3),
2382                                 axis->label[i]);
2383 #else
2384                 layout = gtk_widget_create_pango_layout(g->drawing_area,
2385                                                         axis->label[i]);
2386                 pango_layout_get_pixel_size(layout, &w, &h);
2387                 gdk_draw_layout(axis->pixmap[not_disp], g->fg_gc,
2388                                 axis->s.width - w - 50, 15+h+15 + i*(h+3),
2389                                 layout);
2390                 g_object_unref(G_OBJECT(layout));
2391 #endif
2392         }
2393 }
2394
2395 static void axis_pixmaps_switch (struct axis *axis)
2396 {
2397         axis->displayed = 1 ^ axis->displayed;
2398 }
2399
2400 static void axis_pixmap_display (struct axis *axis)
2401 {
2402         gdk_draw_pixmap (axis->drawing_area->window, axis->g->fg_gc,
2403                         axis->pixmap[axis->displayed], 0, 0, axis->p.x, axis->p.y,
2404                         axis->p.width, axis->p.height);
2405 }
2406
2407 static void axis_compute_ticks (struct axis *axis, double x0, double xmax, int dir)
2408 {
2409         int i, j, ii, jj, ms;
2410         double zoom, x, steps[3]={ 0.1, 0.5 };
2411         int dim, check_needed, diminished;
2412         double majthresh[2]={2.0, 3.0};
2413
2414         debug((DBS_FENTRY | DBS_AXES_TICKS)) puts ("axis_compute_ticks()");
2415         debug(DBS_AXES_TICKS)
2416                 printf ("x0=%f xmax=%f dir=%s\n", x0,xmax, dir?"VERTICAL":"HORIZONTAL");
2417
2418         zoom = axis_zoom_get (axis, dir);
2419         x = xmax-x0;
2420         for (i=-9; i<=12; i++) {
2421                 if (x / pow (10, i) < 1)
2422                         break;
2423         }
2424         --i;
2425         ms = (int )(x / pow (10, i));
2426
2427         if (ms > 5) {
2428                 j = 0;
2429                 ++i;
2430         } else if (ms > 2)
2431                 j = 1;
2432         else
2433                 j = 0;
2434
2435         axis->major = steps[j] * pow (10, i);
2436
2437         debug(DBS_AXES_TICKS) printf ("zoom=%.1f, x=%f -> i=%d -> ms=%d -> j=%d ->"
2438                         " axis->major=%f\n", zoom, x, i, ms, j, axis->major);
2439
2440         /* let's compute minor ticks */
2441         jj = j;
2442         ii = i;
2443         axis_ticks_down (&ii, &jj);
2444         axis->minor = steps[jj] * pow (10, ii);
2445         /* we don't want minors if they would be less than 10 pixels apart */
2446         if (axis->minor*zoom < 10) {
2447                 debug(DBS_AXES_TICKS) printf ("refusing axis->minor of %f: "
2448                                         "axis->minor*zoom == %f\n", axis->minor, axis->minor*zoom);
2449                 axis->minor = 0;
2450         }
2451
2452         check_needed = TRUE;
2453         diminished = FALSE;
2454         while (check_needed) {
2455                 check_needed = FALSE;
2456                 dim = get_label_dim (axis, dir, xmax);
2457                 debug(DBS_AXES_TICKS) printf ("axis->major==%.1f, axis->minor==%.1f =>"
2458                                 " axis->major*zoom/dim==%f, axis->minor*zoom/dim==%f\n",
2459                                 axis->major, axis->minor, axis->major*zoom/dim,
2460                                 axis->minor*zoom/dim);
2461
2462                 /* corrections: if majors are less than majthresh[dir] times label
2463                 * dimension apart, we need to use bigger ones */
2464                 if (axis->major*zoom / dim < majthresh[dir]) {
2465                         axis_ticks_up (&ii, &jj);
2466                         axis->minor = axis->major;
2467                         axis_ticks_up (&i, &j);
2468                         axis->major = steps[j] * pow (10, i);
2469                         check_needed = TRUE;
2470                         debug(DBS_AXES_TICKS) printf ("axis->major enlarged to %.1f\n",
2471                                                                                 axis->major);
2472                 }
2473                 /* if minor ticks are bigger than majthresh[dir] times label dimension,
2474                  * we could  promote them to majors as well */
2475                 if (axis->minor*zoom / dim > majthresh[dir] && !diminished) {
2476                         axis_ticks_down (&i, &j);
2477                         axis->major = axis->minor;
2478                         axis_ticks_down (&ii, &jj);
2479                         axis->minor = steps[jj] * pow (10, ii);
2480                         check_needed = TRUE;
2481                         diminished = TRUE;
2482
2483                         debug(DBS_AXES_TICKS) printf ("axis->minor diminished to %.1f\n",
2484                                                                                 axis->minor);
2485
2486                         if (axis->minor*zoom < 10) {
2487                                 debug(DBS_AXES_TICKS) printf ("refusing axis->minor of %f: "
2488                                         "axis->minor*zoom == %f\n", axis->minor, axis->minor*zoom);
2489                                 axis->minor = 0;
2490                         }
2491                 }
2492         }
2493
2494         debug(DBS_AXES_TICKS) printf ("corrected: axis->major == %.1f -> "
2495                                                         "axis->minor == %.1f\n", axis->major, axis->minor);
2496 }
2497
2498 static void axis_ticks_up (int *i, int *j)
2499 {
2500         (*j)++;
2501         if (*j>1) {
2502                 (*i)++;
2503                 *j=0;
2504         }
2505 }
2506
2507 static void axis_ticks_down (int *i, int *j)
2508 {
2509         (*j)--;
2510         if (*j<0) {
2511                 (*i)--;
2512                 *j=1;
2513         }
2514 }
2515
2516 static int get_label_dim (struct axis *axis, int dir, double label)
2517 {
2518         double y;
2519         char str[32];
2520         int rdigits, dim;
2521 #if GTK_MAJOR_VERSION >= 2
2522         PangoLayout *layout;
2523 #endif
2524
2525          /* First, let's compute how many digits to the right of radix
2526          * we need to print */
2527         y = axis->major - floor (axis->major);
2528         for (rdigits=0; rdigits<=6; rdigits++) {
2529                 y *= 10;
2530                 if (y<=0.000001)
2531                         break;
2532                 y = y - floor (y);
2533         }
2534         snprintf (str, 32, "%.*f", rdigits, label);
2535         switch (dir) {
2536         case AXIS_HORIZONTAL:
2537 #if GTK_MAJOR_VERSION < 2
2538                 dim = gdk_string_width(axis->g->font, str);
2539 #else
2540                 layout = gtk_widget_create_pango_layout(axis->g->drawing_area,
2541                                                         str);
2542                 pango_layout_get_pixel_size(layout, &dim, NULL);
2543                 g_object_unref(G_OBJECT(layout));
2544 #endif
2545                 break;
2546         case AXIS_VERTICAL:
2547 #if GTK_MAJOR_VERSION < 2
2548                 dim = gdk_string_height(axis->g->font, str);
2549 #else
2550                 layout = gtk_widget_create_pango_layout(axis->g->drawing_area,
2551                                                         str);
2552                 pango_layout_get_pixel_size(layout, NULL, &dim);
2553                 g_object_unref(G_OBJECT(layout));
2554 #endif
2555                 break;
2556         default:
2557                 puts ("initialize axis: an axis must be either horizontal or vertical");
2558                 return -1;
2559                 break;
2560         }
2561         return dim;
2562 }
2563
2564 static double axis_zoom_get (struct axis *axis, int dir)
2565 {
2566         switch (dir) {
2567         case AXIS_HORIZONTAL:
2568                 return axis->g->zoom.x;
2569                 break;
2570         case AXIS_VERTICAL:
2571                 return axis->g->zoom.y;
2572                 break;
2573         default:
2574                 return -1;
2575                 break;
2576         }
2577 }
2578
2579 static void graph_select_segment (struct graph *g, int x, int y)
2580 {
2581         struct element_list *list;
2582         struct element *e;
2583
2584         debug(DBS_FENTRY) puts ("graph_select_segment()");
2585
2586         x -= g->geom.x;
2587         y = g->geom.height-1 - (y - g->geom.y);
2588
2589         for (list=g->elists; list; list=list->next)
2590                 for (e=list->elements; e->type != ELMT_NONE; e++) {
2591                         switch (e->type) {
2592                         case ELMT_RECT:
2593                                 break;
2594                         case ELMT_LINE:
2595                                 if (line_detect_collision (e, x, y))
2596                                         goto_frame(&cfile, e->parent->num);
2597                                 break;
2598                         case ELMT_ARC:
2599                                 if (arc_detect_collision (e, x, y))
2600                                         goto_frame(&cfile, e->parent->num);
2601                                 break;
2602                         default:
2603                                 break;
2604                         }
2605                 }
2606 }
2607
2608 static int line_detect_collision (struct element *e, int x, int y)
2609 {
2610         int x1, y1, x2, y2;
2611
2612         if (e->p.line.dim.x1 < e->p.line.dim.x2) {
2613                 x1 = (int )rint (e->p.line.dim.x1);
2614                 x2 = (int )rint (e->p.line.dim.x2);
2615         } else {
2616                 x1 = (int )rint (e->p.line.dim.x2);
2617                 x2 = (int )rint (e->p.line.dim.x1);
2618         }
2619         if (e->p.line.dim.y1 < e->p.line.dim.y2) {
2620                 y1 = (int )rint (e->p.line.dim.y1);
2621                 y2 = (int )rint (e->p.line.dim.y2);
2622         } else {
2623                 y1 = (int )rint (e->p.line.dim.y2);
2624                 y2 = (int )rint (e->p.line.dim.y1);
2625         }
2626         /*
2627         printf ("line: (%d,%d)->(%d,%d), clicked: (%d,%d)\n", x1, y1, x2, y2, x, y);
2628          */
2629         if ((x1==x && x2==x && y1<=y && y<=y2)||(y1==y && y2==y && x1<=x && x<=x2))
2630                 return TRUE;
2631         else
2632                 return FALSE;
2633 }
2634
2635 static int arc_detect_collision (struct element *e, int x, int y)
2636 {
2637         int x1, y1, x2, y2;
2638
2639         x1 = (int )rint (e->p.arc.dim.x);
2640         x2 = (int )rint (e->p.arc.dim.x + e->p.arc.dim.width);
2641         y1 = (int )rint (e->p.arc.dim.y - e->p.arc.dim.height);
2642         y2 = (int )rint (e->p.arc.dim.y);
2643         /*
2644         printf ("arc: (%d,%d)->(%d,%d), clicked: (%d,%d)\n", x1, y1, x2, y2, x, y);
2645          */
2646         if (x1<=x && x<=x2 && y1<=y && y<=y2)
2647                 return TRUE;
2648         else
2649                 return FALSE;
2650 }
2651
2652 static void cross_xor (struct graph *g, int x, int y)
2653 {
2654         if (x > g->wp.x && x < g->wp.x+g->wp.width &&
2655                                 y >= g->wp.y && y < g->wp.y+g->wp.height) {
2656                 gdk_draw_line (g->drawing_area->window, xor_gc, g->wp.x,
2657                                                 y, g->wp.x + g->wp.width, y);
2658                 gdk_draw_line (g->drawing_area->window, xor_gc, x,
2659                                                 g->wp.y, x, g->wp.y + g->wp.height);
2660         }
2661 }
2662
2663 static void cross_draw (struct graph *g, int x, int y)
2664 {
2665         cross_xor (g, x, y);
2666         g->cross.x = x;
2667         g->cross.y = y;
2668         g->cross.erase_needed = 1;
2669 }
2670
2671 static void cross_erase (struct graph *g)
2672 {
2673         cross_xor (g, g->cross.x, g->cross.y);
2674         g->cross.erase_needed = 0;
2675 }
2676
2677 static void magnify_create (struct graph *g, int x, int y)
2678 {
2679         struct graph *mg;
2680         struct element_list *list, *new_list;
2681         struct ipoint pos, offsetpos;
2682         GdkEvent *e=NULL;
2683
2684         mg = g->magnify.g = (struct graph * )malloc (sizeof (struct graph));
2685         memcpy ((void * )mg, (void * )g, sizeof (struct graph));
2686
2687         mg->toplevel = window_new (GTK_WINDOW_POPUP, NULL);
2688         mg->drawing_area = mg->toplevel;
2689         WIDGET_SET_SIZE(mg->toplevel, g->magnify.width, g->magnify.height);
2690         gtk_widget_set_events (mg->drawing_area, GDK_EXPOSURE_MASK
2691                         /*              | GDK_ENTER_NOTIFY_MASK */
2692                         /*              | GDK_ALL_EVENTS_MASK   */
2693                                         );
2694
2695         mg->wp.x = 0;
2696         mg->wp.y = 0;
2697         mg->wp.width = g->magnify.width;
2698         mg->wp.height = g->magnify.height;
2699         mg->geom.width = (int )rint (g->geom.width * g->magnify.zoom.x);
2700         mg->geom.height = (int )rint (g->geom.height * g->magnify.zoom.y);
2701         mg->zoom.x = (mg->geom.width - 1) / g->bounds.width;
2702         mg->zoom.y = (mg->geom.height- 1) / g->bounds.height;
2703
2704         /* in order to keep original element lists intact we need our own */
2705         graph_element_lists_initialize (mg);
2706         list = g->elists->next;
2707         new_list = mg->elists;
2708         for ( ; list; list=list->next) {
2709                 new_list->next =
2710                                 (struct element_list * )malloc (sizeof (struct element_list));
2711                 new_list = new_list->next;
2712                 new_list->next = NULL;
2713                 new_list->elements = NULL;
2714         }
2715         graph_element_lists_make (mg);
2716
2717         gdk_window_get_position (GTK_WIDGET (g->toplevel)->window, &pos.x, &pos.y);
2718         g->magnify.x = pos.x + x - g->magnify.width/2;
2719         g->magnify.y = pos.y + y - g->magnify.height/2;
2720         offsetpos.x = g->magnify.x + g->magnify.offset.x;
2721         offsetpos.x = offsetpos.x >= 0 ? offsetpos.x : 0;
2722         offsetpos.y = g->magnify.y + g->magnify.offset.y;
2723         offsetpos.y = offsetpos.y >= 0 ? offsetpos.y : 0;
2724         gtk_widget_set_uposition (mg->drawing_area, offsetpos.x, offsetpos.y);
2725         magnify_get_geom (g, x, y);
2726
2727         gtk_widget_show (mg->drawing_area);
2728
2729         /* we need to wait for the first expose event before we start drawing */
2730         while (!gdk_events_pending ());
2731         do {
2732                 e = gdk_event_get ();
2733                 if (e) {
2734                         if (e->any.type == GDK_EXPOSE) {
2735                                 gdk_event_free (e);
2736                                 break;
2737                         }
2738                         gdk_event_free (e);
2739                 }
2740         } while (e);
2741
2742         mg->pixmap[0] = mg->pixmap[1] = NULL;
2743         graph_pixmaps_create (mg);
2744         magnify_draw (g);
2745         g->magnify.active = 1;
2746 }
2747
2748 static void magnify_move (struct graph *g, int x, int y)
2749 {
2750         struct ipoint pos, offsetpos;
2751
2752         gdk_window_get_position (GTK_WIDGET (g->toplevel)->window, &pos.x, &pos.y);
2753         g->magnify.x = pos.x + x - g->magnify.width/2;
2754         g->magnify.y = pos.y + y - g->magnify.height/2;
2755         offsetpos.x = g->magnify.x + g->magnify.offset.x;
2756         offsetpos.x = offsetpos.x >= 0 ? offsetpos.x : 0;
2757         offsetpos.y = g->magnify.y + g->magnify.offset.y;
2758         offsetpos.y = offsetpos.y >= 0 ? offsetpos.y : 0;
2759         magnify_get_geom (g, x, y);
2760         gtk_widget_set_uposition (g->magnify.g->drawing_area, offsetpos.x,
2761                                                                 offsetpos.y);
2762         magnify_draw (g);
2763 }
2764
2765 static void magnify_destroy (struct graph *g)
2766 {
2767         struct element_list *list;
2768         struct graph *mg = g->magnify.g;
2769
2770         gtk_widget_destroy (GTK_WIDGET (mg->drawing_area));
2771         gdk_pixmap_unref (mg->pixmap[0]);
2772         gdk_pixmap_unref (mg->pixmap[1]);
2773         for (list=mg->elists; list; list=list->next)
2774                 free (list->elements);
2775         while (mg->elists->next) {
2776                 list = mg->elists->next->next;
2777                 free (mg->elists->next);
2778                 mg->elists->next = list;
2779         }
2780         free (g->magnify.g);
2781         g->magnify.active = 0;
2782 }
2783
2784 static void magnify_get_geom (struct graph *g, int x, int y)
2785 {
2786         int posx, posy;
2787
2788         gdk_window_get_position (GTK_WIDGET (g->toplevel)->window, &posx, &posy);
2789
2790         g->magnify.g->geom.x = g->geom.x;
2791         g->magnify.g->geom.y = g->geom.y;
2792
2793         g->magnify.g->geom.x -=
2794                                 (int )rint ((g->magnify.g->geom.width - g->geom.width) *
2795                                 ((x-g->geom.x)/(double )g->geom.width));
2796         g->magnify.g->geom.y -=
2797                                 (int )rint ((g->magnify.g->geom.height - g->geom.height) *
2798                                 ((y-g->geom.y)/(double )g->geom.height));
2799
2800         /* we have coords of origin of graph relative to origin of g->toplevel.
2801          * now we need them to relate to origin of magnify window */
2802         g->magnify.g->geom.x -= (g->magnify.x - posx);
2803         g->magnify.g->geom.y -= (g->magnify.y - posy);
2804 }
2805
2806 static void magnify_draw (struct graph *g)
2807 {
2808         int not_disp = 1 ^ g->magnify.g->displayed;
2809
2810         graph_pixmap_draw (g->magnify.g);
2811         /* graph pixmap is almost ready, just add border */
2812         gdk_draw_line (g->magnify.g->pixmap[not_disp], g->fg_gc, 0, 0,
2813                                                 g->magnify.width - 1, 0);
2814         gdk_draw_line (g->magnify.g->pixmap[not_disp], g->fg_gc,
2815                         g->magnify.width - 1, 0, g->magnify.width - 1, g->magnify.height);
2816         gdk_draw_line (g->magnify.g->pixmap[not_disp], g->fg_gc, 0, 0,
2817                                                 0, g->magnify.height - 1);
2818         gdk_draw_line (g->magnify.g->pixmap[not_disp], g->fg_gc, 0,
2819                         g->magnify.height - 1, g->magnify.width - 1, g->magnify.height - 1);
2820
2821         graph_pixmaps_switch (g->magnify.g);
2822         graph_pixmap_display (g->magnify.g);
2823
2824 }
2825
2826 static gint configure_event (GtkWidget *widget, GdkEventConfigure *event)
2827 {
2828         struct graph *g;
2829         struct {
2830                 double x, y;
2831         } zoom;
2832         int cur_g_width, cur_g_height;
2833         int cur_wp_width, cur_wp_height;
2834
2835         debug(DBS_FENTRY) puts ("configure_event()");
2836
2837         for (g=graphs; g; g=g->next)
2838                 if (g->drawing_area == widget)
2839                         break;
2840
2841         cur_wp_width = g->wp.width;
2842         cur_wp_height = g->wp.height;
2843         g->wp.width = event->width - g->y_axis->p.width - RMARGIN_WIDTH;
2844         g->wp.height = event->height - g->x_axis->p.height - g->wp.y;
2845         g->x_axis->s.width = g->wp.width;
2846         g->x_axis->p.width = g->wp.width + RMARGIN_WIDTH;
2847         g->y_axis->p.height = g->wp.height + g->wp.y;
2848         g->y_axis->s.height = g->wp.height;
2849         g->x_axis->p.y = g->y_axis->p.height;
2850         zoom.x = (double )g->wp.width / cur_wp_width;
2851         zoom.y = (double )g->wp.height / cur_wp_height;
2852         cur_g_width = g->geom.width;
2853         cur_g_height = g->geom.height;
2854         g->geom.width = (int )rint (g->geom.width * zoom.x);
2855         g->geom.height = (int )rint (g->geom.height * zoom.y);
2856         g->zoom.x = (double )(g->geom.width - 1) / g->bounds.width;
2857         g->zoom.y = (double )(g->geom.height -1) / g->bounds.height;
2858         /* g->zoom.initial.x = g->zoom.x; */
2859         /* g->zoom.initial.y = g->zoom.y; */
2860
2861         g->geom.x = (int) (g->wp.x - (double )g->geom.width/cur_g_width *
2862                                                         (g->wp.x - g->geom.x));
2863         g->geom.y = (int) (g->wp.y - (double )g->geom.height/cur_g_height *
2864                                                         (g->wp.y - g->geom.y));
2865 #if 0
2866         printf ("configure: graph: (%d,%d), (%d,%d); viewport: (%d,%d), (%d,%d); "
2867                                 "zooms: (%f,%f)\n", g->geom.x, g->geom.y, g->geom.width,
2868                                 g->geom.height, g->wp.x, g->wp.y, g->wp.width, g->wp.height,
2869                                 g->zoom.x, g->zoom.y);
2870 #endif
2871
2872         update_zoom_spins (g);
2873         graph_element_lists_make (g);
2874         graph_pixmaps_create (g);
2875         graph_title_pixmap_create (g);
2876         axis_pixmaps_create (g->y_axis);
2877         axis_pixmaps_create (g->x_axis);
2878         /* we don't do actual drawing here; we leave it to expose handler */
2879         graph_pixmap_draw (g);
2880         graph_pixmaps_switch (g);
2881         graph_title_pixmap_draw (g);
2882         h_axis_pixmap_draw (g->x_axis);
2883         axis_pixmaps_switch (g->x_axis);
2884         v_axis_pixmap_draw (g->y_axis);
2885         axis_pixmaps_switch (g->y_axis);
2886         return TRUE;
2887 }
2888
2889 static gint expose_event (GtkWidget *widget, GdkEventExpose *event)
2890 {
2891         struct graph *g;
2892
2893         debug(DBS_FENTRY) puts ("expose_event()");
2894
2895         if (event->count)
2896                 return TRUE;
2897
2898         for (g=graphs; g; g=g->next)
2899                 if (g->drawing_area == widget)
2900                         break;
2901
2902         /* lower left corner */
2903         gdk_draw_rectangle (g->drawing_area->window, g->bg_gc, TRUE, 0,
2904                         g->wp.y + g->wp.height, g->y_axis->p.width, g->x_axis->p.height);
2905         /* right margin */
2906         gdk_draw_rectangle (g->drawing_area->window, g->bg_gc, TRUE,
2907                         g->wp.x + g->wp.width, g->wp.y, RMARGIN_WIDTH, g->wp.height);
2908
2909         graph_pixmap_display (g);
2910         graph_title_pixmap_display (g);
2911         axis_pixmap_display (g->x_axis);
2912         axis_pixmap_display (g->y_axis);
2913
2914         return TRUE;
2915 }
2916
2917 static gint button_press_event (GtkWidget *widget, GdkEventButton *event)
2918 {
2919         struct graph *g;
2920
2921         debug(DBS_FENTRY) puts ("button_press_event()");
2922
2923         for (g=graphs; g; g=g->next)
2924                 if (g->drawing_area == widget)
2925                         break;
2926
2927         if (event->button == 3) {
2928                 if (event->state & GDK_CONTROL_MASK)
2929                         magnify_create (g, (int )rint (event->x), (int )rint (event->y));
2930                 else {
2931                         g->grab.x = (int )rint (event->x) - g->geom.x;
2932                         g->grab.y = (int )rint (event->y) - g->geom.y;
2933                         g->grab.grabbed = TRUE;
2934                 }
2935 #ifdef WIN32
2936                                 /* Windows mouse control:        */
2937                                 /* [<ctrl>-left] - select packet */
2938                                 /* [left] - zoom in              */
2939                                 /* [<shift>-left] - zoom out     */
2940         } else if (event->button == 1) {
2941                 if (event->state & GDK_CONTROL_MASK) {
2942                         graph_select_segment (g, (int)event->x, (int)event->y);
2943                 } else {
2944 #else /* WIN32 */
2945         } else if (event->button == 2) {
2946 #endif
2947                 int cur_width = g->geom.width, cur_height = g->geom.height;
2948                 struct { double x, y; } factor;
2949
2950                 if (g->zoom.flags & ZOOM_OUT) {
2951                         if (g->zoom.flags & ZOOM_HLOCK)
2952                                 factor.x = 1.0;
2953                         else
2954                                 factor.x = 1 / g->zoom.step_x;
2955                         if (g->zoom.flags & ZOOM_VLOCK)
2956                                 factor.y = 1.0;
2957                         else
2958                                 factor.y = 1 / g->zoom.step_y;
2959                 } else {
2960                         if (g->zoom.flags & ZOOM_HLOCK)
2961                                 factor.x = 1.0;
2962                         else
2963                                 factor.x = g->zoom.step_x;
2964                         if (g->zoom.flags & ZOOM_VLOCK)
2965                                 factor.y = 1.0;
2966                         else
2967                                 factor.y = g->zoom.step_y;
2968                 }
2969
2970                 g->geom.width = (int )rint (g->geom.width * factor.x);
2971                 g->geom.height = (int )rint (g->geom.height * factor.y);
2972                 if (g->geom.width < g->wp.width)
2973                         g->geom.width = g->wp.width;
2974                 if (g->geom.height < g->wp.height)
2975                         g->geom.height = g->wp.height;
2976                 g->zoom.x = (g->geom.width - 1) / g->bounds.width;
2977                 g->zoom.y = (g->geom.height- 1) / g->bounds.height;
2978
2979                 g->geom.x -= (int )rint ((g->geom.width - cur_width) *
2980                                                 ((event->x-g->geom.x)/(double )cur_width));
2981                 g->geom.y -= (int )rint ((g->geom.height - cur_height) *
2982                                                 ((event->y-g->geom.y)/(double )cur_height));
2983
2984                 if (g->geom.x > g->wp.x)
2985                         g->geom.x = g->wp.x;
2986                 if (g->geom.y > g->wp.y)
2987                         g->geom.y = g->wp.y;
2988                 if (g->wp.x + g->wp.width > g->geom.x + g->geom.width)
2989                         g->geom.x = g->wp.width + g->wp.x - g->geom.width;
2990                 if (g->wp.y + g->wp.height > g->geom.y + g->geom.height)
2991                         g->geom.y = g->wp.height + g->wp.y - g->geom.height;
2992 #if 0
2993                 printf ("button press: graph: (%d,%d), (%d,%d); viewport: (%d,%d), "
2994                                 "(%d,%d); zooms: (%f,%f)\n", g->geom.x, g->geom.y,
2995                                 g->geom.width, g->geom.height, g->wp.x, g->wp.y, g->wp.width,
2996                                 g->wp.height, g->zoom.x, g->zoom.y);
2997 #endif
2998                 graph_element_lists_make (g);
2999                 g->cross.erase_needed = 0;
3000                 graph_display (g);
3001                 axis_display (g->y_axis);
3002                 axis_display (g->x_axis);
3003                 update_zoom_spins (g);
3004                 if (g->cross.draw)
3005                         cross_draw (g, (int) event->x, (int) event->y);
3006 #ifndef WIN32
3007         } else if (event->button == 1) {
3008                 graph_select_segment (g, (int )event->x, (int )event->y);
3009 #else /* WIN32 */
3010                 }
3011 #endif
3012         }
3013         return TRUE;
3014 }
3015
3016 static gint motion_notify_event (GtkWidget *widget, GdkEventMotion *event)
3017 {
3018         struct graph *g;
3019         int x, y;
3020         GdkModifierType state;
3021
3022         /* debug(DBS_FENTRY) puts ("motion_notify_event()"); */
3023
3024         for (g=graphs; g; g=g->next)
3025                 if (g->drawing_area == widget)
3026                         break;
3027
3028         if (event->is_hint)
3029                 gdk_window_get_pointer (event->window, &x, &y, &state);
3030         else {
3031                 x = (int) event->x;
3032                 y = (int) event->y;
3033                 state = event->state;
3034         }
3035
3036         /* Testing just (state & GDK_BUTTON1_MASK) is not enough since when button1
3037          * is pressed while pointer is in motion, we will receive one more motion
3038          * notify *before* we get the button press. This last motion notify works
3039          * with stale grab coordinates */
3040         if (state & GDK_BUTTON3_MASK) {
3041                 if (g->grab.grabbed) {
3042                         g->geom.x = x-g->grab.x;
3043                         g->geom.y = y-g->grab.y;
3044
3045                         if (g->geom.x > g->wp.x)
3046                                 g->geom.x = g->wp.x;
3047                         if (g->geom.y > g->wp.y)
3048                                 g->geom.y = g->wp.y;
3049                         if (g->wp.x + g->wp.width > g->geom.x + g->geom.width)
3050                                 g->geom.x = g->wp.width + g->wp.x - g->geom.width;
3051                         if (g->wp.y + g->wp.height > g->geom.y + g->geom.height)
3052                                 g->geom.y = g->wp.height + g->wp.y - g->geom.height;
3053                         g->cross.erase_needed = 0;
3054                         graph_display (g);
3055                         axis_display (g->y_axis);
3056                         axis_display (g->x_axis);
3057                         if (g->cross.draw)
3058                                 cross_draw (g, x, y);
3059                 } else if (g->magnify.active)
3060                         magnify_move (g, x, y);
3061         } else if (state & GDK_BUTTON1_MASK) {
3062                 graph_select_segment (g, x, y);
3063                 if (g->cross.erase_needed)
3064                         cross_erase (g);
3065                 if (g->cross.draw)
3066                         cross_draw (g, x, y);
3067         } else {
3068                 if (g->cross.erase_needed)
3069                         cross_erase (g);
3070                 if (g->cross.draw)
3071                         cross_draw (g, x, y);
3072         }
3073
3074         return TRUE;
3075 }
3076
3077 static gint button_release_event (GtkWidget *widget, GdkEventButton *event)
3078 {
3079         struct graph *g;
3080
3081         debug(DBS_FENTRY) puts ("button_release_event()");
3082
3083         for (g=graphs; g; g=g->next)
3084                 if (g->drawing_area == widget)
3085                         break;
3086
3087         if (event->button == 3)
3088                 g->grab.grabbed = FALSE;
3089
3090         if (g->magnify.active)
3091                 magnify_destroy (g);
3092         return TRUE;
3093 }
3094
3095 static gint key_press_event (GtkWidget *widget, GdkEventKey *event)
3096 {
3097         struct graph *g;
3098
3099         debug(DBS_FENTRY) puts ("key_press_event()");
3100
3101         for (g=graphs; g; g=g->next)
3102                 if (g->toplevel == widget)
3103                         break;
3104
3105         if (event->keyval == 32 /*space*/) {
3106                 g->cross.draw ^= 1;
3107 #if 0
3108                 if (g->cross.draw) {
3109                         int x, y;
3110                         gdk_window_get_pointer (g->drawing_area->window, &x, &y, 0);
3111                         cross_draw (g);
3112                 } else if (g->cross.erase_needed) {
3113                         cross_erase (g);
3114                 }
3115 #endif
3116                 /* toggle buttons emit their "toggled" signals so don't bother doing
3117                  * any real work here, it will be done in signal handlers */
3118                 if (g->cross.draw)
3119                         gtk_toggle_button_set_active (g->cross.on_toggle, TRUE);
3120                 else
3121                         gtk_toggle_button_set_active (g->cross.off_toggle, TRUE);
3122         } else if (event->keyval == 't')
3123                 toggle_time_origin (g);
3124         else if (event->keyval == 's')
3125                 toggle_seq_origin (g);
3126         else if (event->keyval == GDK_Shift_L) {
3127                 /* g->zoom.flags |= ZOOM_OUT; */
3128                 gtk_toggle_button_set_active (g->zoom.widget.out_toggle, TRUE);
3129         }
3130         return TRUE;
3131 }
3132
3133 static gint key_release_event (GtkWidget *widget, GdkEventKey *event)
3134 {
3135         struct graph *g;
3136
3137         debug(DBS_FENTRY) puts ("key_release_event()");
3138
3139         for (g=graphs; g; g=g->next)
3140                 if (g->toplevel == widget)
3141                         break;
3142
3143         if (event->keyval == GDK_Shift_L || event->keyval == GDK_ISO_Prev_Group) {
3144                 /* g->zoom.flags &= ~ZOOM_OUT; */
3145                 gtk_toggle_button_set_active (g->zoom.widget.in_toggle, TRUE);
3146         }
3147         return TRUE;
3148 }
3149
3150 static gint leave_notify_event (GtkWidget *widget, GdkEventCrossing *event _U_)
3151 {
3152         struct graph *g;
3153
3154         for (g=graphs; g; g=g->next)
3155                 if (g->drawing_area == widget)
3156                         break;
3157
3158         if (g->cross.erase_needed)
3159                 cross_erase (g);
3160
3161         return TRUE;
3162 }
3163
3164 static gint enter_notify_event (GtkWidget *widget, GdkEventCrossing *event _U_)
3165 {
3166         struct graph *g;
3167
3168         for (g=graphs; g; g=g->next)
3169                 if (g->drawing_area == widget)
3170                         break;
3171
3172         /* graph_pixmap_display (g); */
3173         if (g->cross.draw) {
3174                 int x, y;
3175                 gdk_window_get_pointer (g->drawing_area->window, &x, &y, 0);
3176                 cross_draw (g, x, y);
3177         }
3178         return TRUE;
3179 }
3180
3181 static void toggle_time_origin (struct graph *g)
3182 {
3183         switch (g->type) {
3184         case GRAPH_TSEQ_STEVENS:
3185                 tseq_stevens_toggle_time_origin (g);
3186                 break;
3187         case GRAPH_TSEQ_TCPTRACE:
3188                 tseq_tcptrace_toggle_time_origin (g);
3189                 break;
3190         case GRAPH_THROUGHPUT:
3191                 tput_toggle_time_origin (g);
3192                 break;
3193         default:
3194                 break;
3195         }
3196         axis_display (g->x_axis);
3197 }
3198
3199 static void toggle_seq_origin (struct graph *g)
3200 {