1: /*
2: mtr -- a network diagnostic tool
3: Copyright (C) 1997,1998 Matt Kimball
4: Changes/additions Copyright (C) 1998 R.E.Wolff@BitWizard.nl
5:
6: This program is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License version 2 as
8: published by the Free Software Foundation.
9:
10: This program is distributed in the hope that it will be useful,
11: but WITHOUT ANY WARRANTY; without even the implied warranty of
12: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13: GNU General Public License for more details.
14:
15: You should have received a copy of the GNU General Public License along
16: with this program; if not, write to the Free Software Foundation, Inc.,
17: 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18: */
19:
20: #include "config.h"
21:
22: #include <stdio.h>
23: #include <stdlib.h>
24: #include <unistd.h>
25: #include <sys/time.h>
26: #include <sys/types.h>
27:
28: #ifdef HAVE_GTK
29: #include <string.h>
30: #include <sys/types.h>
31: #include <gtk/gtk.h>
32:
33: #include "mtr.h"
34: #include "net.h"
35: #include "dns.h"
36: #include "asn.h"
37: #include "mtr-gtk.h"
38: #include "utils.h"
39:
40: #include "img/mtr_icon.xpm"
41: #endif
42:
43: static gint gtk_ping(
44: gpointer data);
45: static gint Copy_activate(
46: GtkWidget * widget,
47: gpointer data);
48: static gint NewDestination_activate(
49: GtkWidget * widget,
50: gpointer data);
51: static gboolean ReportTreeView_clicked(
52: GtkWidget * Tree,
53: GdkEventButton * event,
54: gpointer data);
55: static gchar *getSelectedHost(
56: GtkTreePath * path);
57:
58: static int ping_timeout_timer;
59: static GtkWidget *Pause_Button;
60: static GtkWidget *Entry;
61: static GtkWidget *main_window;
62:
63: static void gtk_add_ping_timeout(
64: struct mtr_ctl *ctl)
65: {
66: int dt;
67:
68: if (gtk_toggle_button_get_active((GtkToggleButton *) Pause_Button)) {
69: return;
70: }
71: dt = calc_deltatime(ctl->WaitTime);
72: gtk_redraw(ctl);
73: ping_timeout_timer = g_timeout_add(dt / 1000, gtk_ping, ctl);
74: }
75:
76:
77: static void gtk_do_init(
78: int *argc,
79: char ***argv)
80: {
81: static int done = 0;
82:
83: if (!done) {
84: gtk_init(argc, argv);
85:
86: done = 1;
87: }
88: }
89:
90:
91: int gtk_detect(
92: ATTRIBUTE_UNUSED int *argc,
93: ATTRIBUTE_UNUSED char ***argv)
94: {
95: if (getenv("DISPLAY") != NULL) {
96: /* If we do this here, gtk_init exits on an error. This happens
97: BEFORE the user has had a chance to tell us not to use the
98: display... */
99: return TRUE;
100: } else {
101: return FALSE;
102: }
103: }
104:
105:
106: static gint Window_destroy(
107: ATTRIBUTE_UNUSED GtkWidget * Window,
108: ATTRIBUTE_UNUSED gpointer data)
109: {
110: gtk_main_quit();
111:
112: return FALSE;
113: }
114:
115:
116: static gint Restart_clicked(
117: ATTRIBUTE_UNUSED GtkWidget * Button,
118: gpointer data)
119: {
120: struct mtr_ctl *ctl = (struct mtr_ctl *) data;
121:
122: net_reset(ctl);
123: gtk_redraw(ctl);
124:
125: return FALSE;
126: }
127:
128:
129: static gint Pause_clicked(
130: ATTRIBUTE_UNUSED GtkWidget * Button,
131: gpointer data)
132: {
133: struct mtr_ctl *ctl = (struct mtr_ctl *) data;
134:
135: static int paused = 0;
136:
137: if (paused) {
138: gtk_add_ping_timeout(ctl);
139: } else {
140: g_source_remove(ping_timeout_timer);
141: }
142: paused = !paused;
143: gtk_redraw(ctl);
144:
145: return FALSE;
146: }
147:
148: static gint About_clicked(
149: ATTRIBUTE_UNUSED GtkWidget * Button,
150: ATTRIBUTE_UNUSED gpointer data)
151: {
152: static const gchar *authors[] = {
153: "Matt Kimball <matt.kimball@gmail.com>",
154: "Roger Wolff <R.E.Wolff@BitWizard.nl>",
155: "Bohdan Vlasyuk <bohdan@cec.vstu.vinnica.ua>",
156: "Evgeniy Tretyak <evtr@ukr.net>",
157: "John Thacker <thacker@math.cornell.edu>",
158: "Juha Takala",
159: "David Sward <sward@clark.net>",
160: "David Stone <stone@AsIf.com>",
161: "Andrew Stesin",
162: "Greg Stark <gsstark@mit.edu>",
163: "Robert Sparks <rjsparks@nostrum.com>",
164: "Mike Simons <msimons@moria.simons-clan.com>",
165: "Aaron Scarisbrick,",
166: "Craig Milo Rogers <Rogers@ISI.EDU>",
167: "Antonio Querubin <tony@lavanauts.org>",
168: "Russell Nelson <rn-mtr@crynwr.com>",
169: "Davin Milun <milun@acm.org>",
170: "Josh Martin <jmartin@columbiaservices.net>",
171: "Alexander V. Lukyanov <lav@yars.free.net>",
172: "Charles Levert <charles@comm.polymtl.ca> ",
173: "Bertrand Leconte <B.Leconte@mail.dotcom.fr>",
174: "Anand Kumria",
175: "Olav Kvittem <Olav.Kvittem@uninett.no>",
176: "Adam Kramer <l3zqc@qcunix1.acc.qc.edu> ",
177: "Philip Kizer <pckizer@nostrum.com>",
178: "Simon Kirby",
179: "Sami Kerola <kerolasa@iki.fi>",
180: "Christophe Kalt",
181: "Steve Kann <stevek@spheara.horizonlive.com>",
182: "Brett Johnson <brett@jdacareers.com>",
183: "Roland Illig <roland.illig@gmx.de>",
184: "Damian Gryski <dgryski@uwaterloo.ca>",
185: "Rob Foehl <rwf@loonybin.net>",
186: "Mircea Damian",
187: "Cougar <cougar@random.ee>",
188: "Travis Cross <tc@traviscross.com>",
189: "Brian Casey",
190: "Andrew Brown <atatat@atatdot.net>",
191: "Bill Bogstad <bogstad@pobox.com> ",
192: "Marc Bejarano <marc.bejarano@openwave.com>",
193: "Moritz Barsnick <barsnick@gmx.net>",
194: "Thomas Klausner <wiz@NetBSD.org>",
195: NULL
196: };
197:
198: gtk_show_about_dialog(GTK_WINDOW(main_window)
199: , "version", PACKAGE_VERSION, "copyright",
200: "Copyright \xc2\xa9 1997,1998 Matt Kimball",
201: "website", "https://www.bitwizard.nl/mtr/",
202: "authors", authors, "comments",
203: "The 'traceroute' and 'ping' programs in a single network diagnostic tool.",
204: "license",
205: "This program is free software; you can redistribute it and/or modify\n"
206: "it under the terms of the GNU General Public License version 2 as\n"
207: "published by the Free Software Foundation.\n"
208: "\n"
209: "This program is distributed in the hope that it will be useful,\n"
210: "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
211: "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
212: "GNU General Public License for more details.",
213: NULL);
214: return TRUE;
215: }
216:
217: /*
218: * There is a small problem with the following code:
219: * The timeout is canceled and removed in order to ensure that
220: * it takes effect (consider what happens if you set the timeout to 999,
221: * then try to undo the change); is a better approach possible?
222: *
223: * What's the problem with this? (-> "I don't think so)
224: */
225:
226: static gint WaitTime_changed(
227: ATTRIBUTE_UNUSED GtkAdjustment * Adj,
228: GtkWidget * data)
229: {
230: struct mtr_ctl *ctl = (struct mtr_ctl *) data;
231: GtkWidget *Button = (GtkWidget *) ctl->gtk_data;
232:
233: ctl->WaitTime = gtk_spin_button_get_value(GTK_SPIN_BUTTON(Button));
234: g_source_remove(ping_timeout_timer);
235: gtk_add_ping_timeout(ctl);
236: gtk_redraw(ctl);
237:
238: return FALSE;
239: }
240:
241:
242: static gint Host_activate(
243: GtkWidget * entry,
244: gpointer data)
245: {
246: struct mtr_ctl *ctl = (struct mtr_ctl *) data;
247: struct addrinfo *res = NULL;
248:
249: ctl->af = DEFAULT_AF; // should this obey the cmd line option?
250: ctl->Hostname = gtk_entry_get_text(GTK_ENTRY(entry));
251: if (get_addrinfo_from_name(ctl, &res, ctl->Hostname) == 0) {
252: net_reopen(ctl, res);
253: freeaddrinfo(res);
254: net_send_batch(ctl);
255: /* If we are "Paused" at this point it is usually because someone
256: entered a non-existing host. Therefore do the go-ahead... */
257: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Pause_Button), 0);
258: } else {
259: int pos = strlen(gtk_entry_get_text(GTK_ENTRY(entry)));
260: gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(Pause_Button), 1);
261: gtk_editable_insert_text(GTK_EDITABLE(entry), ": not found", -1,
262: &pos);
263: }
264:
265: return FALSE;
266: }
267:
268:
269:
270: static void Toolbar_fill(
271: struct mtr_ctl *ctl,
272: GtkWidget * Toolbar)
273: {
274: GtkWidget *Button;
275: GtkWidget *Label;
276: GtkAdjustment *Adjustment;
277:
278: Button = gtk_button_new_with_label("Quit");
279: gtk_box_pack_end(GTK_BOX(Toolbar), Button, FALSE, FALSE, 0);
280: g_signal_connect(G_OBJECT(Button), "clicked",
281: G_CALLBACK(Window_destroy), NULL);
282:
283: Button = gtk_button_new_with_label("About");
284: gtk_box_pack_end(GTK_BOX(Toolbar), Button, FALSE, FALSE, 0);
285: g_signal_connect(G_OBJECT(Button), "clicked",
286: G_CALLBACK(About_clicked), NULL);
287:
288: Button = gtk_button_new_with_mnemonic("_Restart");
289: gtk_box_pack_end(GTK_BOX(Toolbar), Button, FALSE, FALSE, 0);
290: g_signal_connect(G_OBJECT(Button), "clicked",
291: G_CALLBACK(Restart_clicked), ctl);
292:
293: Pause_Button = gtk_toggle_button_new_with_mnemonic("_Pause");
294: gtk_box_pack_end(GTK_BOX(Toolbar), Pause_Button, FALSE, FALSE, 0);
295: g_signal_connect(G_OBJECT(Pause_Button), "clicked",
296: G_CALLBACK(Pause_clicked), ctl);
297:
298: /* allow root only to set zero delay */
299: Adjustment = (GtkAdjustment *) gtk_adjustment_new(ctl->WaitTime,
300: running_as_root() ? 0.01 : 1.00,
301: 999.99, 1.0, 10.0,
302: 0.0);
303: Button = gtk_spin_button_new(Adjustment, 0.5, 2);
304: gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(Button), TRUE);
305: gtk_box_pack_end(GTK_BOX(Toolbar), Button, FALSE, FALSE, 0);
306: ctl->gtk_data = Button;
307: g_signal_connect(G_OBJECT(Adjustment), "value_changed",
308: G_CALLBACK(WaitTime_changed), ctl);
309:
310: Label = gtk_label_new_with_mnemonic("_Hostname:");
311: gtk_box_pack_start(GTK_BOX(Toolbar), Label, FALSE, FALSE, 0);
312:
313: Entry = gtk_entry_new();
314: gtk_entry_set_text(GTK_ENTRY(Entry), ctl->Hostname);
315: g_signal_connect(G_OBJECT(Entry), "activate",
316: G_CALLBACK(Host_activate), ctl);
317: gtk_box_pack_start(GTK_BOX(Toolbar), Entry, TRUE, TRUE, 0);
318:
319: gtk_label_set_mnemonic_widget(GTK_LABEL(Label), Entry);
320: }
321:
322: static GtkWidget *ReportTreeView;
323: static GtkListStore *ReportStore;
324:
325: enum {
326: #ifdef HAVE_IPINFO
327: COL_ASN,
328: #endif
329: COL_HOSTNAME,
330: COL_LOSS,
331: COL_RCV,
332: COL_SNT,
333: COL_LAST,
334: COL_BEST,
335: COL_AVG,
336: COL_WORST,
337: COL_STDEV,
338: COL_COLOR,
339: N_COLS
340: };
341:
342: /* Trick to cast a pointer to integer. We are mis-using a pointer as a
343: single integer. On 64-bit architectures, the pointer is 64 bits and the
344: integer only 32. The compiler warns us of loss of precision. However we
345: know we casted a normal 32-bit integer into this pointer a few
346: microseconds earlier, so it is ok. Nothing to worry about. */
347: #define POINTER_TO_INT(p) ((int)(long)(p))
348:
349: static void float_formatter(
350: GtkTreeViewColumn * tree_column ATTRIBUTE_UNUSED,
351: GtkCellRenderer * cell,
352: GtkTreeModel * tree_model,
353: GtkTreeIter * iter,
354: gpointer data)
355: {
356: gfloat f;
357: gchar text[64];
358: gtk_tree_model_get(tree_model, iter, POINTER_TO_INT(data), &f, -1);
359: sprintf(text, "%.2f", f);
360: g_object_set(cell, "text", text, NULL);
361: }
362:
363: static void percent_formatter(
364: GtkTreeViewColumn * tree_column ATTRIBUTE_UNUSED,
365: GtkCellRenderer * cell,
366: GtkTreeModel * tree_model,
367: GtkTreeIter * iter,
368: gpointer data)
369: {
370: gfloat f;
371: gchar text[64];
372: gtk_tree_model_get(tree_model, iter, POINTER_TO_INT(data), &f, -1);
373: sprintf(text, "%.1f%%", f);
374: g_object_set(cell, "text", text, NULL);
375: }
376:
377: static void TreeViewCreate(
378: struct mtr_ctl *ctl)
379: {
380: GtkCellRenderer *renderer;
381: GtkTreeViewColumn *column;
382:
383: ReportStore = gtk_list_store_new(N_COLS,
384: #ifdef HAVE_IPINFO
385: G_TYPE_STRING,
386: #endif
387: G_TYPE_STRING,
388: G_TYPE_FLOAT,
389: G_TYPE_INT,
390: G_TYPE_INT,
391: G_TYPE_INT,
392: G_TYPE_INT,
393: G_TYPE_INT,
394: G_TYPE_INT,
395: G_TYPE_FLOAT, G_TYPE_STRING);
396:
397: ReportTreeView =
398: gtk_tree_view_new_with_model(GTK_TREE_MODEL(ReportStore));
399:
400: g_signal_connect(G_OBJECT(ReportTreeView), "button_press_event",
401: G_CALLBACK(ReportTreeView_clicked), ctl);
402:
403: #ifdef HAVE_IPINFO
404: if (is_printii(ctl)) {
405: renderer = gtk_cell_renderer_text_new();
406: column = gtk_tree_view_column_new_with_attributes("ASN",
407: renderer,
408: "text", COL_ASN,
409: "foreground",
410: COL_COLOR, NULL);
411: gtk_tree_view_column_set_resizable(column, TRUE);
412: gtk_tree_view_append_column(GTK_TREE_VIEW(ReportTreeView), column);
413: }
414: #endif
415:
416: renderer = gtk_cell_renderer_text_new();
417: column = gtk_tree_view_column_new_with_attributes("Hostname",
418: renderer,
419: "text", COL_HOSTNAME,
420: "foreground",
421: COL_COLOR, NULL);
422: gtk_tree_view_column_set_expand(column, TRUE);
423: gtk_tree_view_column_set_resizable(column, TRUE);
424: gtk_tree_view_append_column(GTK_TREE_VIEW(ReportTreeView), column);
425:
426: renderer = gtk_cell_renderer_text_new();
427: g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
428: column = gtk_tree_view_column_new_with_attributes("Loss",
429: renderer,
430: "text", COL_LOSS,
431: "foreground",
432: COL_COLOR, NULL);
433: gtk_tree_view_column_set_resizable(column, TRUE);
434: gtk_tree_view_column_set_cell_data_func(column, renderer,
435: percent_formatter,
436: (void *) COL_LOSS, NULL);
437: gtk_tree_view_append_column(GTK_TREE_VIEW(ReportTreeView), column);
438:
439: renderer = gtk_cell_renderer_text_new();
440: g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
441: column = gtk_tree_view_column_new_with_attributes("Snt",
442: renderer,
443: "text", COL_SNT,
444: "foreground",
445: COL_COLOR, NULL);
446: gtk_tree_view_column_set_resizable(column, TRUE);
447: gtk_tree_view_append_column(GTK_TREE_VIEW(ReportTreeView), column);
448:
449: renderer = gtk_cell_renderer_text_new();
450: g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
451: column = gtk_tree_view_column_new_with_attributes("Last",
452: renderer,
453: "text", COL_LAST,
454: "foreground",
455: COL_COLOR, NULL);
456: gtk_tree_view_column_set_resizable(column, TRUE);
457: gtk_tree_view_append_column(GTK_TREE_VIEW(ReportTreeView), column);
458:
459: renderer = gtk_cell_renderer_text_new();
460: g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
461: column = gtk_tree_view_column_new_with_attributes("Avg",
462: renderer,
463: "text", COL_AVG,
464: "foreground",
465: COL_COLOR, NULL);
466: gtk_tree_view_column_set_resizable(column, TRUE);
467: gtk_tree_view_append_column(GTK_TREE_VIEW(ReportTreeView), column);
468:
469: renderer = gtk_cell_renderer_text_new();
470: g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
471: column = gtk_tree_view_column_new_with_attributes("Best",
472: renderer,
473: "text", COL_BEST,
474: "foreground",
475: COL_COLOR, NULL);
476: gtk_tree_view_column_set_resizable(column, TRUE);
477: gtk_tree_view_append_column(GTK_TREE_VIEW(ReportTreeView), column);
478:
479: renderer = gtk_cell_renderer_text_new();
480: g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
481: column = gtk_tree_view_column_new_with_attributes("Worst",
482: renderer,
483: "text", COL_WORST,
484: "foreground",
485: COL_COLOR, NULL);
486: gtk_tree_view_column_set_resizable(column, TRUE);
487: gtk_tree_view_append_column(GTK_TREE_VIEW(ReportTreeView), column);
488:
489: renderer = gtk_cell_renderer_text_new();
490: g_object_set(G_OBJECT(renderer), "xalign", 1.0, NULL);
491: column = gtk_tree_view_column_new_with_attributes("StDev",
492: renderer,
493: "text", COL_STDEV,
494: "foreground",
495: COL_COLOR, NULL);
496: gtk_tree_view_column_set_resizable(column, TRUE);
497: gtk_tree_view_column_set_cell_data_func(column, renderer,
498: float_formatter,
499: (void *) COL_STDEV, NULL);
500: gtk_tree_view_append_column(GTK_TREE_VIEW(ReportTreeView), column);
501:
502: }
503:
504: static void update_tree_row(
505: struct mtr_ctl *ctl,
506: int row,
507: GtkTreeIter * iter)
508: {
509: ip_t *addr;
510: char str[256] = "???", *name = str;
511:
512: addr = net_addr(row);
513: if (addrcmp(addr, &ctl->unspec_addr, ctl->af)) {
514: if ((name = dns_lookup(ctl, addr))) {
515: if (ctl->show_ips) {
516: snprintf(str, sizeof(str), "%s (%s)", name,
517: strlongip(ctl->af, addr));
518: name = str;
519: }
520: } else
521: name = strlongip(ctl->af, addr);
522: }
523:
524: gtk_list_store_set(ReportStore, iter,
525: COL_HOSTNAME, name,
526: COL_LOSS, (float) (net_loss(row) / 1000.0),
527: COL_RCV, net_returned(row),
528: COL_SNT, net_xmit(row),
529: COL_LAST, net_last(row) / 1000,
530: COL_BEST, net_best(row) / 1000,
531: COL_AVG, net_avg(row) / 1000,
532: COL_WORST, net_worst(row) / 1000,
533: COL_STDEV, (float) (net_stdev(row) / 1000.0),
534: COL_COLOR, net_up(row) ? NULL : "red", -1);
535: #ifdef HAVE_IPINFO
536: if (is_printii(ctl))
537: gtk_list_store_set(ReportStore, iter, COL_ASN,
538: fmt_ipinfo(ctl, addr), -1);
539: #endif
540: }
541:
542: void gtk_redraw(
543: struct mtr_ctl *ctl)
544: {
545: int max = net_max(ctl);
546:
547: GtkTreeIter iter;
548: int row = net_min(ctl);
549: gboolean valid;
550:
551: valid =
552: gtk_tree_model_get_iter_first(GTK_TREE_MODEL(ReportStore), &iter);
553:
554: while (valid) {
555: if (row < max) {
556: update_tree_row(ctl, row++, &iter);
557: valid =
558: gtk_tree_model_iter_next(GTK_TREE_MODEL(ReportStore),
559: &iter);
560: } else {
561: valid = gtk_list_store_remove(ReportStore, &iter);
562: }
563: }
564: while (row < max) {
565: gtk_list_store_append(ReportStore, &iter);
566: update_tree_row(ctl, row++, &iter);
567: }
568: }
569:
570: // GTK 3 has changed the interface a bit. Here a few defines so that we can
571: // work with GTK2 or GTK3 as required.
572: #ifdef HAVE_GTK3
573: #define gtk_vbox_new_(orientation,sz) gtk_box_new(orientation, sz)
574: #define gtk_hbox_new_(orientation,sz) gtk_box_new(orientation, sz)
575: #else
576: #define gtk_vbox_new_(orientation,sz) gtk_vbox_new(FALSE, sz)
577: #define gtk_hbox_new_(orientation,sz) gtk_hbox_new(FALSE, sz)
578: #endif
579:
580: static void Window_fill(
581: struct mtr_ctl *ctl,
582: GtkWidget * Window)
583: {
584: GtkWidget *VBox;
585: GtkWidget *Toolbar;
586: GtkWidget *scroll;
587:
588: gtk_window_set_title(GTK_WINDOW(Window), "My traceroute");
589: gtk_window_set_default_size(GTK_WINDOW(Window), 650, 400);
590: gtk_container_set_border_width(GTK_CONTAINER(Window), 10);
591:
592: VBox = gtk_vbox_new_(GTK_ORIENTATION_VERTICAL, 10);
593: Toolbar = gtk_hbox_new_(GTK_ORIENTATION_HORIZONTAL, 10);
594:
595: Toolbar_fill(ctl, Toolbar);
596: gtk_box_pack_start(GTK_BOX(VBox), Toolbar, FALSE, FALSE, 0);
597:
598: TreeViewCreate(ctl);
599: scroll = gtk_scrolled_window_new(NULL, NULL);
600: gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
601: GTK_POLICY_AUTOMATIC,
602: GTK_POLICY_AUTOMATIC);
603: gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll),
604: GTK_SHADOW_IN);
605: gtk_container_add(GTK_CONTAINER(scroll), ReportTreeView);
606: gtk_box_pack_start(GTK_BOX(VBox), scroll, TRUE, TRUE, 0);
607:
608: gtk_container_add(GTK_CONTAINER(Window), VBox);
609: }
610:
611:
612: void gtk_open(
613: struct mtr_ctl *ctl)
614: {
615: GdkPixbuf *icon;
616: int argc = 1;
617: char *args[2];
618: char **argv;
619:
620: argv = args;
621: argv[0] = xstrdup("");
622: argv[1] = NULL;
623: gtk_do_init(&argc, &argv);
624: free(argv[0]);
625:
626: icon = gdk_pixbuf_new_from_xpm_data((const char **) mtr_icon);
627: gtk_window_set_default_icon(icon);
628:
629: main_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
630:
631: g_set_application_name("My traceroute");
632:
633: Window_fill(ctl, main_window);
634:
635: g_signal_connect(G_OBJECT(main_window), "delete_event",
636: G_CALLBACK(Window_destroy), NULL);
637: g_signal_connect(G_OBJECT(main_window), "destroy",
638: G_CALLBACK(Window_destroy), NULL);
639:
640: gtk_widget_show_all(main_window);
641: }
642:
643:
644: void gtk_close(
645: void)
646: {
647: }
648:
649:
650: int gtk_keyaction(
651: void)
652: {
653: return 0;
654: }
655:
656:
657: static gint gtk_ping(
658: gpointer data)
659: {
660: struct mtr_ctl *ctl = (struct mtr_ctl *) data;
661:
662: gtk_redraw(ctl);
663: net_send_batch(ctl);
664: net_harvest_fds(ctl);
665: g_source_remove(ping_timeout_timer);
666: gtk_add_ping_timeout(ctl);
667: return TRUE;
668: }
669:
670:
671: static gboolean gtk_net_data(
672: ATTRIBUTE_UNUSED GIOChannel * channel,
673: ATTRIBUTE_UNUSED GIOCondition cond,
674: gpointer data)
675: {
676: struct mtr_ctl *ctl = (struct mtr_ctl *) data;
677:
678: net_process_return(ctl);
679: return TRUE;
680: }
681:
682:
683: static gboolean gtk_dns_data(
684: ATTRIBUTE_UNUSED GIOChannel * channel,
685: ATTRIBUTE_UNUSED GIOCondition cond,
686: gpointer data)
687: {
688: struct mtr_ctl *ctl = (struct mtr_ctl *) data;
689:
690: dns_ack(ctl);
691: gtk_redraw(ctl);
692: return TRUE;
693: }
694:
695: #ifdef ENABLE_IPV6
696: static gboolean gtk_dns_data6(
697: ATTRIBUTE_UNUSED GIOChannel * channel,
698: ATTRIBUTE_UNUSED GIOCondition cond,
699: gpointer data)
700: {
701: struct mtr_ctl *ctl = (struct mtr_ctl *) data;
702:
703: dns_ack6();
704: gtk_redraw(ctl);
705: return TRUE;
706: }
707: #endif
708:
709:
710: void gtk_loop(
711: struct mtr_ctl *ctl)
712: {
713: GIOChannel *net_iochannel, *dns_iochannel;
714:
715: gtk_add_ping_timeout(ctl);
716:
717: net_iochannel = g_io_channel_unix_new(net_waitfd());
718: g_io_add_watch(net_iochannel, G_IO_IN, gtk_net_data, ctl);
719: #ifdef ENABLE_IPV6
720: if (dns_waitfd6() > 0) {
721: dns_iochannel = g_io_channel_unix_new(dns_waitfd6());
722: g_io_add_watch(dns_iochannel, G_IO_IN, gtk_dns_data6, ctl);
723: }
724: #endif
725: dns_iochannel = g_io_channel_unix_new(dns_waitfd());
726: g_io_add_watch(dns_iochannel, G_IO_IN, gtk_dns_data, ctl);
727:
728: gtk_main();
729: }
730:
731: static gboolean NewDestination_activate(
732: GtkWidget * widget ATTRIBUTE_UNUSED,
733: gpointer data)
734: {
735: gchar *hostname;
736: struct mtr_ctl *ctl = (struct mtr_ctl *) data;
737: GtkTreePath *path = (GtkTreePath *) ctl->gtk_data;
738:
739: hostname = getSelectedHost(path);
740: if (hostname) {
741: ctl->gtk_data = hostname;
742: gtk_entry_set_text(GTK_ENTRY(Entry), hostname);
743: Host_activate(Entry, ctl);
744: g_free(hostname);
745: }
746: return TRUE;
747: }
748:
749:
750: static gboolean Copy_activate(
751: GtkWidget * widget ATTRIBUTE_UNUSED,
752: gpointer data)
753: {
754: gchar *hostname;
755: GtkTreePath *path = (GtkTreePath *) data;
756:
757: hostname = getSelectedHost(path);
758: if (hostname != NULL) {
759: GtkClipboard *clipboard;
760:
761: clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
762: gtk_clipboard_set_text(clipboard, hostname, -1);
763:
764: clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
765: gtk_clipboard_set_text(clipboard, hostname, -1);
766:
767: g_free(hostname);
768: }
769:
770: return TRUE;
771: }
772:
773: static gchar *getSelectedHost(
774: GtkTreePath * path)
775: {
776: GtkTreeIter iter;
777: gchar *name = NULL;
778:
779: if (gtk_tree_model_get_iter(GTK_TREE_MODEL(ReportStore), &iter, path)) {
780: gtk_tree_model_get(GTK_TREE_MODEL(ReportStore), &iter,
781: COL_HOSTNAME, &name, -1);
782: }
783: gtk_tree_path_free(path);
784: return name;
785: }
786:
787:
788: static gboolean ReportTreeView_clicked(
789: GtkWidget * Tree ATTRIBUTE_UNUSED,
790: GdkEventButton * event,
791: gpointer data)
792: {
793: GtkWidget *popup_menu;
794: GtkWidget *copy_item;
795: GtkWidget *newdestination_item;
796: GtkTreePath *path;
797: struct mtr_ctl *ctl = (struct mtr_ctl *) data;
798:
799: if (event->type != GDK_BUTTON_PRESS || event->button != 3)
800: return FALSE;
801:
802: if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(ReportTreeView),
803: event->x, event->y, &path, NULL,
804: NULL, NULL))
805: return FALSE;
806:
807: gtk_tree_view_set_cursor(GTK_TREE_VIEW(ReportTreeView), path, NULL,
808: FALSE);
809:
810: /* Single right click: prepare and show the popup menu */
811: popup_menu = gtk_menu_new();
812:
813: copy_item = gtk_menu_item_new_with_label("Copy to clipboard");
814: newdestination_item =
815: gtk_menu_item_new_with_label("Set as new destination");
816:
817: gtk_menu_shell_append(GTK_MENU_SHELL(popup_menu), copy_item);
818: gtk_menu_shell_append(GTK_MENU_SHELL(popup_menu), newdestination_item);
819:
820: g_signal_connect(G_OBJECT(copy_item), "activate",
821: G_CALLBACK(Copy_activate), path);
822:
823: ctl->gtk_data = path;
824: g_signal_connect(G_OBJECT(newdestination_item), "activate",
825: G_CALLBACK(NewDestination_activate), ctl);
826:
827: gtk_widget_show(copy_item);
828: gtk_widget_show(newdestination_item);
829:
830: #ifdef HAVE_GTK3
831: gtk_menu_popup_at_pointer(GTK_MENU(popup_menu), NULL);
832: #else
833: gtk_menu_popup(GTK_MENU(popup_menu), NULL, NULL, NULL, NULL,
834: 0, event->time);
835: #endif
836: return TRUE;
837: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to gtk.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / mtr / ui