← Back to branch summary

~hloeung/ubuntu/utopic/mtr/fix-ipv6-nameservers

« back to all changes in this revision

Viewing changes to gtk.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Woodcock
  • Date: 2008-09-22 07:30:21 UTC
  • mfrom: (1.1.6 upstream) (5.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20080922073021-bbf4yd480q25o5b9
Tags: 0.75-2
http://bugs.debian.org/499789
Use rm -f in rules clean target where necessary, closes: #499789

Show diffs side-by-side

added added

removed removed

Lines of Context:
gtk.c
42
42
#endif
43
43
 
44
44
gint gtk_ping(gpointer data);
 
45
gint Copy_activate(GtkWidget *widget, gpointer data);
 
46
gint NewDestination_activate(GtkWidget *widget, gpointer data);
 
47
gboolean ReportTreeView_clicked(GtkWidget *Tree, GdkEventButton *event);
 
48
gchar* getSelectedHost(GtkTreePath *path);
 
49
 
45
50
 
46
51
 
47
52
extern char *Hostname;
49
54
extern int af;
50
55
static int tag;
51
56
static GtkWidget *Pause_Button;
52
 
 
 
57
static GtkWidget *Entry;
53
58
 
54
59
void gtk_add_ping_timeout (void)
55
60
{
56
61
  int dt;
57
62
 
58
63
  dt = calc_deltatime (WaitTime);
59
 
  tag = gtk_timeout_add(dt / 1000, gtk_ping, NULL);
 
64
  tag = g_timeout_add(dt / 1000, gtk_ping, NULL);
60
65
}
61
66
 
62
67
 
109
114
  if (paused) {
110
115
    gtk_add_ping_timeout ();
111
116
  } else {
112
 
    gtk_timeout_remove (tag);
 
117
    g_source_remove (tag);
113
118
  }
114
119
  paused = ! paused;
115
120
  gtk_redraw();
129
134
 
130
135
gint WaitTime_changed(UNUSED GtkAdjustment *Adj, UNUSED GtkWidget *Button) 
131
136
{
132
 
  WaitTime = gtk_spin_button_get_value_as_float(GTK_SPIN_BUTTON(Button));
133
 
  gtk_timeout_remove (tag);
 
137
  WaitTime = gtk_spin_button_get_value(GTK_SPIN_BUTTON(Button));
 
138
  g_source_remove (tag);
134
139
  gtk_add_ping_timeout ();
135
140
  gtk_redraw();
136
141
 
147
152
    net_reopen(addr);
148
153
    /* If we are "Paused" at this point it is usually because someone
149
154
       entered a non-existing host. Therefore do the go-ahead... --REW */
150
 
    gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON( Pause_Button ) , 0);
 
155
    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( Pause_Button ) , 0);
151
156
  } else {
152
 
    gtk_toggle_button_set_state( GTK_TOGGLE_BUTTON( Pause_Button ) , 1);
153
 
    gtk_entry_append_text( GTK_ENTRY(Entry), ": not found" );
 
157
    int pos = strlen(gtk_entry_get_text( GTK_ENTRY(Entry)));
 
158
    gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( Pause_Button ) , 1);
 
159
    gtk_editable_insert_text( GTK_EDITABLE(Entry), ": not found", -1, &pos);
154
160
  }
155
161
 
156
162
  return FALSE;
169
175
{
170
176
  GtkWidget *Button;
171
177
  GtkWidget *Label;
172
 
  GtkWidget *Entry;
173
178
  GtkAdjustment *Adjustment;
174
179
 
175
 
  Button = gtk_button_new_with_label("Quit");
 
180
  Button = gtk_button_new_from_stock(GTK_STOCK_QUIT);
176
181
  gtk_box_pack_end(GTK_BOX(Toolbar), Button, FALSE, FALSE, 0);
177
 
  gtk_signal_connect(GTK_OBJECT(Button), "clicked",
 
182
  g_signal_connect(GTK_OBJECT(Button), "clicked",
178
183
                     GTK_SIGNAL_FUNC(Window_destroy), NULL);
179
 
  gtk_widget_show(Button);
180
184
 
181
 
  Button = gtk_button_new_with_label("Restart");
 
185
  Button = gtk_button_new_with_mnemonic("_Restart");
182
186
  gtk_box_pack_end(GTK_BOX(Toolbar), Button, FALSE, FALSE, 0);
183
 
  gtk_signal_connect(GTK_OBJECT(Button), "clicked",
 
187
  g_signal_connect(GTK_OBJECT(Button), "clicked",
184
188
                     GTK_SIGNAL_FUNC(Restart_clicked), NULL);
185
 
  gtk_widget_show(Button);
186
189
 
187
 
  Pause_Button = gtk_toggle_button_new_with_label("Pause");
 
190
  Pause_Button = gtk_toggle_button_new_with_mnemonic("_Pause");
188
191
  gtk_box_pack_end(GTK_BOX(Toolbar), Pause_Button, FALSE, FALSE, 0);
189
 
  gtk_signal_connect(GTK_OBJECT(Pause_Button), "clicked",
 
192
  g_signal_connect(GTK_OBJECT(Pause_Button), "clicked",
190
193
                    GTK_SIGNAL_FUNC(Pause_clicked), NULL);
191
 
  gtk_widget_show(Pause_Button);
192
194
 
193
195
  /* allow root only to set zero delay */
194
196
  Adjustment = (GtkAdjustment *)gtk_adjustment_new(WaitTime,
195
 
                                                  getuid()==0 ? 0.00:1.00,
 
197
                                                  getuid()==0 ? 0.01:1.00,
196
198
                                                 999.99,
197
199
                                                  1.0, 10.0,
198
200
                                                  0.0);
202
204
  /* gtk_spin_button_set_set_update_policy(GTK_SPIN_BUTTON(Button),
203
205
     GTK_UPDATE_IF_VALID); */
204
206
  gtk_box_pack_end(GTK_BOX(Toolbar), Button, FALSE, FALSE, 0);
205
 
  gtk_signal_connect(GTK_OBJECT(Adjustment), "value_changed",
 
207
  g_signal_connect(GTK_OBJECT(Adjustment), "value_changed",
206
208
                    GTK_SIGNAL_FUNC(WaitTime_changed), Button);
207
 
  gtk_widget_show(Button);
208
209
 
209
 
  Label = gtk_label_new("Hostname");
 
210
  Label = gtk_label_new_with_mnemonic("_Hostname:");
210
211
  gtk_box_pack_start(GTK_BOX(Toolbar), Label, FALSE, FALSE, 0);
211
 
  gtk_widget_show(Label);
212
212
 
213
213
  Entry = gtk_entry_new();
214
214
  gtk_entry_set_text(GTK_ENTRY(Entry), Hostname);
215
 
  gtk_signal_connect(GTK_OBJECT(Entry), "activate",
 
215
  g_signal_connect(GTK_OBJECT(Entry), "activate",
216
216
                     GTK_SIGNAL_FUNC(Host_activate), NULL);
217
217
  gtk_box_pack_start(GTK_BOX(Toolbar), Entry, TRUE, TRUE, 0);
218
 
  gtk_widget_show(Entry);
219
 
}
220
 
 
221
 
 
222
 
char *Report_Text[] = { "Hostname", "Loss", "Rcv", "Snt", "Last", "Best", "Avg", "Worst", "StDev", NULL };
223
 
int Report_Positions[] = { 10, 200, 240, 280, 320, 360, 400, 440, 480, 0 };
224
 
GtkWidget *Report;
225
 
GtkWidget *ReportBody;
226
 
 
227
 
GtkWidget *GetRow(int index) 
228
 
{
229
 
  ip_t * addr;
230
 
  char *name;
231
 
  GtkWidget *Row, *Label;
232
 
 
233
 
  Row = gtk_fixed_new();
234
 
  
235
 
  addr = net_addr(index);
236
 
  name = "???";
237
 
  if ( addrcmp( (void *) addr, (void *) &unspec_addr, af ) != 0 ) {
238
 
    name = dns_lookup(addr);
239
 
    if(!name) {
240
 
      /* Actually this is not neccesary: 
241
 
         dns_lookup always returns a printable string */
242
 
      name = strlongip (addr);
243
 
    }
244
 
  }
245
 
 
246
 
  Label = gtk_label_new(name);
247
 
  gtk_fixed_put(GTK_FIXED(Row), Label, Report_Positions[0], 0);
248
 
  gtk_widget_show(Label);
249
 
 
250
 
  return Row;
251
 
}
252
 
 
253
 
 
254
 
GtkWidget *Scrollarea_create(void)
255
 
{
256
 
  GtkWidget *List;
257
 
  GtkWidget *scroll;
258
 
  int count;
259
 
 
260
 
  for(count = 0; Report_Positions[count]; count++);
261
 
 
262
 
  List = GTK_WIDGET(gtk_clist_new_with_titles(count, Report_Text));
263
 
  scroll = gtk_scrolled_window_new(NULL, NULL);
264
 
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
265
 
  for(count = 0; Report_Positions[count + 1]; count++) {
266
 
    gtk_clist_set_column_width(GTK_CLIST(List), count, 
267
 
                               Report_Positions[count + 1] - 
268
 
                               Report_Positions[count]);
269
 
  }
270
 
  gtk_clist_set_column_width(GTK_CLIST(List), count, 0);
271
 
  for(count = 1; Report_Positions[count]; count++) {
272
 
    gtk_clist_set_column_justification(GTK_CLIST(List), count, GTK_JUSTIFY_RIGHT);
273
 
  }
274
 
  gtk_container_add(GTK_CONTAINER(scroll), List);
275
 
  gtk_widget_show(List);
276
 
 
277
 
  ReportBody = List;
278
 
  return scroll;
279
 
}
280
 
 
281
 
 
282
 
void gtk_add_row(GtkWidget *List) 
283
 
{
284
 
  int at;
285
 
  GtkWidget *Row, *Label;
286
 
 
287
 
  Row = gtk_fixed_new();
288
 
  
289
 
  for(at = 0; Report_Positions[at] != 0; at++) {
290
 
    Label = gtk_label_new("-");
291
 
    if(at) {
292
 
      gtk_widget_set_usize(Label, 40, 0);
293
 
      gtk_label_set_justify(GTK_LABEL(Label), GTK_JUSTIFY_RIGHT);
294
 
    }
295
 
    gtk_fixed_put(GTK_FIXED(Row), Label, Report_Positions[at], 0);
296
 
    gtk_widget_show(Label);
297
 
  }
298
 
 
299
 
  gtk_box_pack_start(GTK_BOX(List), Row, FALSE, FALSE, 0);
300
 
  gtk_widget_show(Row);
301
 
}
302
 
 
303
 
 
304
 
void gtk_set_field(GtkCList *List, int row, int ix, char *str) {
305
 
  gtk_clist_set_text(List, row, ix, str);
306
 
}
307
 
 
308
 
 
309
 
/*   void gtk_set_field_num(GtkCList *List, int row, int ix, char *format, int num) {
310
 
             changed int to dobule byMin */
311
 
void gtk_set_field_num(GtkCList *List, int row, int ix, char *format, double num) 
312
 
{
313
 
  char str[32];
314
 
 
315
 
  sprintf(str, format, num);
316
 
  gtk_set_field(List, row, ix, str);
317
 
}
318
 
 
319
 
 
320
 
void gtk_update_row(GtkCList *List, int row) 
 
218
  
 
219
  gtk_label_set_mnemonic_widget(GTK_LABEL(Label), Entry);
 
220
}
 
221
 
 
222
static GtkWidget *ReportTreeView;
 
223
static GtkListStore *ReportStore;
 
224
 
 
225
enum {
 
226
  COL_HOSTNAME,
 
227
  COL_LOSS,
 
228
  COL_RCV,
 
229
  COL_SNT,
 
230
  COL_LAST,
 
231
  COL_BEST,
 
232
  COL_AVG,
 
233
  COL_WORST,
 
234
  COL_STDEV,
 
235
  COL_COLOR,
 
236
  N_COLS
 
237
};
 
238
 
 
239
void  float_formatter(GtkTreeViewColumn *tree_column,
 
240
  GtkCellRenderer   *cell, 
 
241
  GtkTreeModel      *tree_model,
 
242
  GtkTreeIter       *iter, 
 
243
  gpointer           data)
 
244
{
 
245
  gfloat f;
 
246
  gchar text[64];
 
247
  gtk_tree_model_get(tree_model, iter, (gint)data, &f, -1);
 
248
  sprintf(text, "%.2f", f);
 
249
  g_object_set(cell, "text", text, NULL);
 
250
}
 
251
 
 
252
void  percent_formatter(GtkTreeViewColumn *tree_column,
 
253
  GtkCellRenderer   *cell, 
 
254
  GtkTreeModel      *tree_model,
 
255
  GtkTreeIter       *iter, 
 
256
  gpointer           data)
 
257
{
 
258
  gfloat f;
 
259
  gchar text[64];
 
260
  gtk_tree_model_get(tree_model, iter, (gint)data, &f, -1);
 
261
  sprintf(text, "%.1f%%", f);
 
262
  g_object_set(cell, "text", text, NULL);
 
263
}
 
264
 
 
265
void TreeViewCreate(void)
 
266
{
 
267
  GtkCellRenderer *renderer;
 
268
  GtkTreeViewColumn *column;
 
269
 
 
270
  ReportStore = gtk_list_store_new(N_COLS,
 
271
    G_TYPE_STRING,
 
272
    G_TYPE_FLOAT,
 
273
    G_TYPE_INT,
 
274
    G_TYPE_INT,
 
275
    G_TYPE_INT,
 
276
    G_TYPE_INT,
 
277
    G_TYPE_INT,
 
278
    G_TYPE_INT,
 
279
    G_TYPE_FLOAT,
 
280
    G_TYPE_STRING
 
281
    );
 
282
    
 
283
  ReportTreeView = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ReportStore));
 
284
  
 
285
  g_signal_connect(GTK_OBJECT(ReportTreeView), "button_press_event", 
 
286
                    G_CALLBACK(ReportTreeView_clicked),NULL);
 
287
  
 
288
  renderer = gtk_cell_renderer_text_new ();
 
289
  column = gtk_tree_view_column_new_with_attributes ("Hostname",
 
290
    renderer,
 
291
    "text", COL_HOSTNAME,
 
292
    "foreground", COL_COLOR,
 
293
    NULL);
 
294
  gtk_tree_view_column_set_expand(column, TRUE);
 
295
  gtk_tree_view_column_set_resizable(column, TRUE);
 
296
  gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column);
 
297
 
 
298
  renderer = gtk_cell_renderer_text_new ();
 
299
  g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL);
 
300
  column = gtk_tree_view_column_new_with_attributes ("Loss",
 
301
    renderer,
 
302
    "text", COL_LOSS,
 
303
    "foreground", COL_COLOR,
 
304
    NULL);
 
305
  gtk_tree_view_column_set_resizable(column, TRUE);
 
306
  gtk_tree_view_column_set_cell_data_func(column, renderer, percent_formatter, (void*)COL_LOSS, NULL);
 
307
  gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column);
 
308
 
 
309
  renderer = gtk_cell_renderer_text_new ();
 
310
  g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL);
 
311
  column = gtk_tree_view_column_new_with_attributes ("Rcv",
 
312
    renderer,
 
313
    "text", 2,
 
314
    "foreground", COL_COLOR,
 
315
    NULL);
 
316
  gtk_tree_view_column_set_resizable(column, TRUE);
 
317
  gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column);
 
318
 
 
319
  renderer = gtk_cell_renderer_text_new ();
 
320
  g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL);
 
321
  column = gtk_tree_view_column_new_with_attributes ("Snt",
 
322
    renderer,
 
323
    "text", 3,
 
324
    "foreground", COL_COLOR,
 
325
    NULL);
 
326
  gtk_tree_view_column_set_resizable(column, TRUE);
 
327
  gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column);
 
328
 
 
329
  renderer = gtk_cell_renderer_text_new ();
 
330
  g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL);
 
331
  column = gtk_tree_view_column_new_with_attributes ("Last",
 
332
    renderer,
 
333
    "text", 4,
 
334
    "foreground", COL_COLOR,
 
335
    NULL);
 
336
  gtk_tree_view_column_set_resizable(column, TRUE);
 
337
  gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column);
 
338
 
 
339
  renderer = gtk_cell_renderer_text_new ();
 
340
  g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL);
 
341
  column = gtk_tree_view_column_new_with_attributes ("Best",
 
342
    renderer,
 
343
    "text", 5,
 
344
    "foreground", COL_COLOR,
 
345
    NULL);
 
346
  gtk_tree_view_column_set_resizable(column, TRUE);
 
347
  gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column);
 
348
 
 
349
  renderer = gtk_cell_renderer_text_new ();
 
350
  g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL);
 
351
  column = gtk_tree_view_column_new_with_attributes ("Avg",
 
352
    renderer,
 
353
    "text", 6,
 
354
    "foreground", COL_COLOR,
 
355
    NULL);
 
356
  gtk_tree_view_column_set_resizable(column, TRUE);
 
357
  gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column);
 
358
 
 
359
  renderer = gtk_cell_renderer_text_new ();
 
360
  g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL);
 
361
  column = gtk_tree_view_column_new_with_attributes ("Worst",
 
362
    renderer,
 
363
    "text", 7,
 
364
    "foreground", COL_COLOR,
 
365
    NULL);
 
366
  gtk_tree_view_column_set_resizable(column, TRUE);
 
367
  gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column);
 
368
 
 
369
  renderer = gtk_cell_renderer_text_new ();
 
370
  g_object_set (G_OBJECT(renderer), "xalign", 1.0, NULL);
 
371
  column = gtk_tree_view_column_new_with_attributes ("StDev",
 
372
    renderer,
 
373
    "text", 8,
 
374
    "foreground", COL_COLOR,
 
375
    NULL);
 
376
  gtk_tree_view_column_set_resizable(column, TRUE);
 
377
  gtk_tree_view_column_set_cell_data_func(column, renderer, float_formatter, (void*)COL_STDEV, NULL);
 
378
  gtk_tree_view_append_column (GTK_TREE_VIEW(ReportTreeView), column);
 
379
 
 
380
}
 
381
 
 
382
void update_tree_row(int row, GtkTreeIter *iter)
321
383
{
322
384
  ip_t *addr;
323
385
  char str[256], *name;
324
 
  GdkColor color;
325
 
  GdkColormap *cmap;
326
386
 
327
387
  addr = net_addr(row);
328
388
  name = "???";
334
394
    }
335
395
  }
336
396
 
337
 
  cmap = gtk_widget_get_colormap(ReportBody);
338
 
  if (net_up(row)) {
339
 
    gdk_color_black(cmap, &color);
340
 
  } else {
341
 
    color.red = 0xffff;
342
 
    color.green = 0;
343
 
    color.blue = 0;
344
 
  }
345
 
  gdk_color_alloc (cmap, &color);
346
 
  gtk_clist_set_foreground(List, row, &color);
347
 
 
348
 
  /* changed the format type and added stdev and first/max TTL byMin */
349
 
  /* the row - net_min() is kind of not clean, need some more work */
350
 
  gtk_set_field(List, row - net_min(), 0, name);
351
 
 
352
 
  gtk_set_field_num(List, row - net_min(), 1, "%.1f%%", net_loss(row)/1000.0);
353
 
  gtk_set_field_num(List, row - net_min(), 2, "%.0f", net_returned(row));  
354
 
  gtk_set_field_num(List, row - net_min(), 3, "%.0f", net_xmit(row));
355
 
  
356
 
  gtk_set_field_num(List, row - net_min(), 4, "%.0f", net_last(row)/1000.0);
357
 
  gtk_set_field_num(List, row - net_min(), 5, "%.0f", net_best(row)/1000.0);
358
 
  gtk_set_field_num(List, row - net_min(), 6, "%.0f", net_avg(row)/1000.0);  
359
 
  gtk_set_field_num(List, row - net_min(), 7, "%.0f", net_worst(row)/1000.0);
360
 
  gtk_set_field_num(List, row - net_min(), 8, "%.2f", net_stdev(row)/1000.0);
 
397
  gtk_list_store_set(ReportStore, iter,
 
398
    COL_HOSTNAME, name,
 
399
    COL_LOSS, (float)(net_loss(row)/1000.0),
 
400
 
 
401
    COL_RCV, net_returned(row),
 
402
    COL_SNT, net_xmit(row),
 
403
 
 
404
    COL_LAST, net_last(row)/1000,
 
405
    COL_BEST, net_best(row)/1000,
 
406
    COL_AVG, net_avg(row)/1000,
 
407
    COL_WORST, net_worst(row)/1000,
 
408
    COL_STDEV, (float)(net_stdev(row)/1000.0),
 
409
    
 
410
    COL_COLOR, net_up(row) ? "black" : "red",
 
411
 
 
412
    -1);
361
413
}
362
414
 
363
 
 
364
415
void gtk_redraw(void)
365
416
{
366
 
  int at  = net_min();  /* changed from 0 to net_min for TTL stuff byMin */
367
417
  int max = net_max();
368
 
 
369
 
  gtk_clist_freeze(GTK_CLIST(ReportBody));
370
 
 
371
 
  while(GTK_CLIST(ReportBody)->rows < max -at) {        /* byMin */
372
 
    gtk_clist_append(GTK_CLIST(ReportBody), Report_Text);
373
 
  }
374
 
 
375
 
  while(GTK_CLIST(ReportBody)->rows > max) {
376
 
    gtk_clist_remove(GTK_CLIST(ReportBody), GTK_CLIST(ReportBody)->rows - 1);
377
 
  }
378
 
 
379
 
  /* for(at=0; at < max; at++) {         replaced byMin */
380
 
  for(; at < max; at++) {
381
 
    gtk_update_row(GTK_CLIST(ReportBody), at);
382
 
  }
383
 
 
384
 
  gtk_clist_thaw(GTK_CLIST(ReportBody));
 
418
  
 
419
  GtkTreeIter iter;
 
420
  int row = net_min();
 
421
  gboolean valid;
 
422
 
 
423
  valid = gtk_tree_model_get_iter_first(GTK_TREE_MODEL(ReportStore), &iter);
 
424
 
 
425
  while(valid) {
 
426
    if(row < max) {
 
427
      update_tree_row(row++, &iter);
 
428
      valid = gtk_tree_model_iter_next(GTK_TREE_MODEL(ReportStore), &iter);
 
429
    } else {
 
430
      valid = gtk_list_store_remove(ReportStore, &iter);
 
431
    }
 
432
  }
 
433
  while(row < max) {
 
434
    gtk_list_store_append(ReportStore, &iter);
 
435
    update_tree_row(row++, &iter);
 
436
  }
385
437
}
386
438
 
387
439
 
389
441
{
390
442
  GtkWidget *VBox;
391
443
  GtkWidget *Toolbar;
392
 
  GtkWidget *List;
 
444
  GtkWidget *scroll;
393
445
 
394
446
  gtk_window_set_title(GTK_WINDOW(Window), "My traceroute  [v" VERSION "]");
395
 
  gtk_window_set_wmclass(GTK_WINDOW(Window), "mtr", "Mtr");
396
 
  gtk_widget_set_usize(Window, 600, 400); 
397
 
  gtk_container_border_width(GTK_CONTAINER(Window), 10);
 
447
  gtk_window_set_default_size(GTK_WINDOW(Window), 650, 400); 
 
448
  gtk_container_set_border_width(GTK_CONTAINER(Window), 10);
398
449
  VBox = gtk_vbox_new(FALSE, 10);
399
450
 
400
451
  Toolbar = gtk_hbox_new(FALSE, 10);
401
452
  Toolbar_fill(Toolbar);
402
453
  gtk_box_pack_start(GTK_BOX(VBox), Toolbar, FALSE, FALSE, 0);
403
 
  gtk_widget_show(Toolbar);
 
454
  
 
455
  TreeViewCreate();
 
456
  scroll = gtk_scrolled_window_new(NULL, NULL);
 
457
  gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
 
458
  gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(scroll), GTK_SHADOW_IN);
 
459
  gtk_container_add(GTK_CONTAINER(scroll), ReportTreeView);
 
460
  gtk_box_pack_start(GTK_BOX(VBox), scroll, TRUE, TRUE, 0);
404
461
 
405
 
  List = Scrollarea_create();
406
 
  gtk_box_pack_start(GTK_BOX(VBox), List, TRUE, TRUE, 0);
407
 
  gtk_widget_show(List);
408
 
  
409
462
  gtk_container_add(GTK_CONTAINER(Window), VBox);
410
 
  gtk_widget_show(VBox);
411
463
}
412
464
 
413
465
 
429
481
 
430
482
  Window_fill(Window);
431
483
 
432
 
  gtk_signal_connect_object(GTK_OBJECT(Window), "delete_event",
433
 
                            GTK_SIGNAL_FUNC(gtk_widget_destroy), 
434
 
                            GTK_OBJECT(Window));
435
 
  gtk_signal_connect(GTK_OBJECT(Window), "destroy",
 
484
  g_signal_connect(GTK_OBJECT(Window), "delete_event",
 
485
                     GTK_SIGNAL_FUNC(Window_destroy), NULL);
 
486
  g_signal_connect(GTK_OBJECT(Window), "destroy",
436
487
                     GTK_SIGNAL_FUNC(Window_destroy), NULL);
437
488
 
438
489
  icon = gtk_load_pixmap(mtr_icon);
439
 
  gtk_widget_show(Window);
 
490
  gtk_widget_show_all(Window);
440
491
  gdk_window_set_icon(Window->window, NULL, icon, NULL);
441
492
  gdk_window_set_icon_name(Window->window, "mtr");
442
493
}
457
508
{
458
509
  gtk_redraw();
459
510
  net_send_batch();
460
 
  gtk_timeout_remove (tag);
 
511
  g_source_remove (tag);
461
512
  gtk_add_ping_timeout ();
462
513
  return TRUE;
463
514
}
464
515
 
465
516
 
466
 
void gtk_net_data(UNUSED gpointer data, UNUSED gint fd, UNUSED GdkInputCondition cond) 
 
517
gboolean gtk_net_data(UNUSED GIOChannel *channel, UNUSED GIOCondition cond, UNUSED gpointer data) 
467
518
{
468
519
  net_process_return();
 
520
  return TRUE;
469
521
}
470
522
 
471
523
 
472
 
void gtk_dns_data(UNUSED gpointer data, UNUSED gint fd, UNUSED GdkInputCondition cond) 
 
524
gboolean gtk_dns_data(UNUSED GIOChannel *channel, UNUSED GIOCondition cond, UNUSED gpointer data)
473
525
{
474
526
  dns_ack();
475
527
  gtk_redraw();
 
528
  return TRUE;
476
529
}
477
530
 
478
531
 
479
532
void gtk_loop(void) 
480
533
{
 
534
  GIOChannel *net_iochannel, *dns_iochannel;
 
535
 
481
536
  gtk_add_ping_timeout ();
482
 
  gdk_input_add(net_waitfd(), GDK_INPUT_READ, gtk_net_data, NULL);
483
 
  gdk_input_add(dns_waitfd(), GDK_INPUT_READ, gtk_dns_data, NULL);
 
537
  
 
538
  net_iochannel = g_io_channel_unix_new(net_waitfd());
 
539
  g_io_add_watch(net_iochannel, G_IO_IN, gtk_net_data, NULL);
 
540
  dns_iochannel = g_io_channel_unix_new(dns_waitfd());
 
541
  g_io_add_watch(dns_iochannel, G_IO_IN, gtk_dns_data, NULL);
484
542
 
485
543
  gtk_main();
486
544
}
487
545
 
 
546
gboolean NewDestination_activate(GtkWidget *widget, gpointer data)
 
547
{
 
548
  gchar *hostname;
 
549
  GtkTreePath *path = (GtkTreePath*)data;
 
550
        
 
551
  hostname = getSelectedHost(path);
 
552
  if (hostname) {
 
553
    gtk_entry_set_text (GTK_ENTRY(Entry), hostname);
 
554
    Host_activate(Entry, NULL);
 
555
    g_free(hostname);
 
556
  }
 
557
  return TRUE;
 
558
}
 
559
 
 
560
 
 
561
gboolean Copy_activate(GtkWidget *widget, gpointer data)
 
562
{
 
563
  gchar *hostname;
 
564
  GtkTreePath *path = (GtkTreePath*)data;
 
565
        
 
566
  hostname = getSelectedHost(path);
 
567
  if (hostname != NULL) {
 
568
    GtkClipboard *clipboard;
 
569
 
 
570
    clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
 
571
    gtk_clipboard_set_text(clipboard, hostname, -1);
 
572
 
 
573
    clipboard = gtk_clipboard_get(GDK_SELECTION_PRIMARY);
 
574
    gtk_clipboard_set_text(clipboard, hostname, -1);
 
575
 
 
576
    g_free(hostname);
 
577
  }
 
578
 
 
579
  return TRUE;
 
580
}
 
581
 
 
582
gchar *getSelectedHost(GtkTreePath *path)
 
583
{
 
584
  GtkTreeIter iter;
 
585
  gchar *name = NULL;
 
586
 
 
587
  if (gtk_tree_model_get_iter(GTK_TREE_MODEL(ReportStore), &iter, path)) {
 
588
    gtk_tree_model_get (GTK_TREE_MODEL(ReportStore), &iter, COL_HOSTNAME, &name, -1);
 
589
  }
 
590
  gtk_tree_path_free(path);
 
591
  return name;
 
592
}
 
593
 
 
594
 
 
595
gboolean ReportTreeView_clicked(GtkWidget *Tree, GdkEventButton *event)
 
596
{
 
597
  GtkWidget* popup_menu; 
 
598
  GtkWidget* copy_item; 
 
599
  GtkWidget* newdestination_item;
 
600
  GtkTreePath *path;
 
601
 
 
602
  if (event->type != GDK_BUTTON_PRESS  || event->button != 3)
 
603
    return FALSE;
 
604
 
 
605
  if(!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(ReportTreeView),
 
606
      event->x, event->y, &path, NULL, NULL, NULL))
 
607
    return FALSE;
 
608
  
 
609
  gtk_tree_view_set_cursor(GTK_TREE_VIEW(ReportTreeView), path, NULL, FALSE);
 
610
 
 
611
  // Single right click: prepare and show the popup menu
 
612
  popup_menu = gtk_menu_new ();
 
613
 
 
614
  copy_item = gtk_menu_item_new_with_label ("Copy to clipboard");
 
615
  newdestination_item = gtk_menu_item_new_with_label ("Set as new destination"); 
 
616
 
 
617
  gtk_menu_append (GTK_MENU (popup_menu), copy_item); 
 
618
  gtk_menu_append (GTK_MENU (popup_menu), newdestination_item); 
 
619
 
 
620
  g_signal_connect(GTK_OBJECT(copy_item),"activate",
 
621
                   GTK_SIGNAL_FUNC(Copy_activate), path);
 
622
 
 
623
  g_signal_connect(GTK_OBJECT(newdestination_item),"activate",
 
624
                   GTK_SIGNAL_FUNC(NewDestination_activate), path);
 
625
              
 
626
  gtk_widget_show (copy_item); 
 
627
  gtk_widget_show (newdestination_item); 
 
628
 
 
629
  gtk_menu_popup (GTK_MENU(popup_menu), NULL, NULL, NULL, NULL,
 
630
                   0, event->time);
 
631
  return TRUE;
 
632
}
488
633