git.meshlink.io Git - meshlink/blob - src/pokey/interface.c

   1 /*
   2     interface.c -- GTK+/GNOME interface functions
   3     Copyright (C) 2002 Guus Sliepen <guus@sliepen.warande.net>,
   4                   2002 Ivo Timmermans <ivo@o2w.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 as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20     $Id: interface.c,v 1.4 2002/04/28 12:46:26 zarq Exp $
  21 */
  22
  23 #include "config.h"
  24
  25 #include <stdarg.h>
  26 #include <stdio.h>
  27 #include <string.h>
  28 #include <sys/time.h>
  29
  30 #define log mathlog
  31 #include <math.h>
  32 #undef log
  33
  34 #include <gtk/gtk.h>
  35 #include <glade/glade.h>
  36 #include <libgnomeui/gnome-canvas.h>
  37 #include <libgnomeui/gnome-canvas-rect-ellipse.h>
  38 #include <libgnomeui/gnome-canvas-text.h>
  39 #include <libgnomeui/gnome-canvas-line.h>
  40 #include <libgnomeui/gnome-canvas-util.h>
  41
  42 #include "node.h"
  43 #include "connection.h"
  44 #include "edge.h"
  45 #include "interface.h"
  46 #include "logging.h"
  47
  48 #include <hooks.h>
  49 #include <xalloc.h>
  50
  51 #include "system.h"
  52
  53 extern GladeXML *xml;
  54
  55 #ifdef MAXBUFSIZE
  56 #undef MAXBUFSIZE
  57 #endif
  58
  59 #define MAXBUFSIZE 1024
  60
  61 int build_graph = 0;
  62
  63 static GdkColormap *colormap = NULL;
  64 static GdkColor timecolor;
  65
  66 #define MAX_NODES 25
  67 #define K 10.0
  68
  69 #ifdef INFINITY
  70 #undef INFINITY
  71 #endif
  72 #define INFINITY 1.0e10
  73
  74 node_t *nodes[MAX_NODES];
  75 double x[MAX_NODES];
  76 double y[MAX_NODES];
  77 double k[MAX_NODES][MAX_NODES];
  78 double d[MAX_NODES][MAX_NODES];
  79 double l[MAX_NODES][MAX_NODES];
  80 const double epsilon = 0.001;
  81
  82 static int inited = 0;
  83
  84 static int number_of_nodes = 0;
  85
  86 static GtkWidget *nodetree;
  87 static GtkCTreeNode *hosts_ctn;
  88
  89 static GnomeCanvasGroup *edge_group = NULL;
  90
  91 static int canvas_width;
  92 static int canvas_height;
  93
  94 static GtkWidget *canvas = NULL;
  95
  96 static int log_inited = 0;
  97 static int follow_log = 1;
  98
  99 static int keep_drawing = 1;
 100
 101 static GtkCList *connlist = NULL;
 102
 103 static double canvas_zoom = 1.00;
 104
 105 void if_node_add(const char *hooktype, va_list ap);
 106 void if_node_del(const char *hooktype, va_list ap);
 107 void if_subnet_add(const char *hooktype, va_list ap);
 108 void if_subnet_del(const char *hooktype, va_list ap);
 109 void if_edge_add(const char *hooktype, va_list ap);
 110 void if_edge_del(const char *hooktype, va_list ap);
 111 void if_node_visible(const char *hooktype, va_list ap);
 112 void if_node_invisible(const char *hooktype, va_list ap);
 113
 114 GtkWidget *create_canvas(void)
 115 {
 116   canvas = glade_xml_get_widget(xml, "canvas1");
 117   if(!canvas)
 118     {
 119       fprintf(stderr, "Could not find widget `canvas1'\n");
 120       return NULL;
 121     }
 122
 123   gnome_canvas_set_scroll_region(GNOME_CANVAS(canvas), -00.0, -00.0, 700, 500);
 124
 125   canvas_width = 300.0;
 126   canvas_height = 500.0;
 127
 128   return canvas;
 129 }
 130
 131 void log_gtk(int level, int priority, char *fmt, va_list ap)
 132 {
 133   char buffer1[MAXBUFSIZE];
 134   char buffer2[MAXBUFSIZE];
 135   GtkWidget *w;
 136   int len;
 137   char *p;
 138   struct tm *tm;
 139   time_t t;
 140
 141   if(!xml)
 142     return;
 143
 144   w = glade_xml_get_widget(xml, "Messages");
 145   if(!w)
 146     return;
 147
 148   /* Use vsnprintf instead of vasprintf: faster, no memory
 149      fragmentation, cleanup is automatic, and there is a limit on the
 150      input buffer anyway */
 151   len = vsnprintf(buffer1, MAXBUFSIZE, fmt, ap);
 152
 153   buffer1[MAXBUFSIZE-1] = '\0';
 154   if((p = strrchr(buffer1, '\n')))
 155     *p = '\0';
 156
 157   t = time(NULL);
 158   tm = localtime(&t);
 159   snprintf(buffer2, MAXBUFSIZE, "%02d:%02d:%02d ",
 160            tm->tm_hour, tm->tm_min, tm->tm_sec);
 161
 162   if(!colormap)
 163     {
 164       colormap = gdk_colormap_new(gdk_visual_get_system(), FALSE);
 165       timecolor.red = 0xffff;
 166       timecolor.green = 0;
 167       timecolor.blue = 0;
 168       if(gdk_colormap_alloc_color(colormap, &timecolor, FALSE, TRUE) != TRUE)
 169         {
 170           fprintf(stderr, "Failed to allocate color\n");
 171           exit(1);
 172         }
 173     }
 174
 175   gtk_text_freeze(GTK_TEXT(w));
 176
 177   if(log_inited)
 178     gtk_text_insert(GTK_TEXT(w), NULL, NULL, NULL, "\n", 1);
 179
 180   gtk_text_insert(GTK_TEXT(w), NULL, &timecolor, NULL, buffer2, strlen(buffer2));
 181   gtk_text_insert(GTK_TEXT(w), NULL, NULL, NULL, buffer1, len);
 182   gtk_text_thaw(GTK_TEXT(w));
 183
 184   log_inited = 1;
 185   if(follow_log)
 186 /*     gtk_text_set_point(GTK_TEXT(w), -1); */
 187     gtk_editable_set_position(GTK_EDITABLE(w), gtk_text_get_length(GTK_TEXT(w)));
 188 }
 189
 190 void if_hostinfoclosebutton_clicked(GtkWidget *w, gpointer data)
 191 {
 192   gtk_widget_destroy(GTK_WIDGET(data));
 193 }
 194
 195 void update_hostinfo_dialog(GladeXML *x, node_t *n)
 196 {
 197   GtkWidget *w;
 198   char s[100];
 199   avl_node_t *avlnode;
 200   char *l[1];
 201
 202   w = glade_xml_get_widget(x, "HostInfoNameEntry");
 203   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoNameEntry"); return; }
 204   gtk_entry_set_text(GTK_ENTRY(w), n->name);
 205
 206   w = glade_xml_get_widget(x, "HostInfoHostnameEntry");
 207   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoHostnameEntry"); return; }
 208   gtk_entry_set_text(GTK_ENTRY(w), n->hostname);
 209
 210   w = glade_xml_get_widget(x, "HostInfoPortEntry");
 211   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoPortEntry"); return; }
 212 /*   snprintf(s, sizeof(s)-1, "%hd", "0"); */
 213   gtk_entry_set_text(GTK_ENTRY(w), "port");
 214
 215   w = glade_xml_get_widget(x, "HostInfoVersionEntry");
 216   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoVersionEntry"); return; }
 217   gtk_entry_set_text(GTK_ENTRY(w), n->name);
 218
 219   w = glade_xml_get_widget(x, "HostInfoStatusEntry");
 220   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoStatusEntry"); return; }
 221 /*   snprintf(s, sizeof(s)-1, "%x", n->status); */
 222   gtk_entry_set_text(GTK_ENTRY(w), "0");
 223
 224   w = glade_xml_get_widget(x, "HostInfoActiveCheckbutton");
 225   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoActiveCheckbutton"); return; }
 226   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), n->status.active);
 227
 228   w = glade_xml_get_widget(x, "HostInfoValidkeyCheckbutton");
 229   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoValidkeyCheckbutton"); return; }
 230   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), n->status.validkey);
 231
 232   w = glade_xml_get_widget(x, "HostInfoWaitingforkeyCheckbutton");
 233   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoWaitingforkeyCheckbutton"); return; }
 234   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), n->status.waitingforkey);
 235
 236   w = glade_xml_get_widget(x, "HostInfoVisitedCheckbutton");
 237   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoVisitedCheckbutton"); return; }
 238   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), n->status.visited);
 239
 240   w = glade_xml_get_widget(x, "HostInfoReachableCheckbutton");
 241   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoReachableCheckbutton"); return; }
 242   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), n->status.reachable);
 243
 244   w = glade_xml_get_widget(x, "HostInfoIndirectCheckbutton");
 245   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoIndirectCheckbutton"); return; }
 246   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), n->status.indirect);
 247
 248   w = glade_xml_get_widget(x, "HostInfoVisibleCheckbutton");
 249   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoVisibleCheckbutton"); return; }
 250 /*   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), n->status.visible); */
 251
 252   w = glade_xml_get_widget(x, "HostInfoTCPOnlyCheckbutton");
 253   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoTCPOnlyCheckbutton"); return; }
 254   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), (n->options & OPTION_TCPONLY) != 0);
 255
 256   w = glade_xml_get_widget(x, "HostInfoIndirectdataCheckbutton");
 257   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoIndirectdataCheckbutton"); return; }
 258   gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(w), (n->options & OPTION_INDIRECT) != 0);
 259
 260 /*   w = glade_xml_get_widget(x, "HostInfoWindow"); */
 261 /*   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostInfoWindow"); return; } */
 262 /*   glade_xml_signal_connect_data(x, "on_HostInfoCloseButton_clicked", if_hostinfoclosebutton_clicked, (gpointer)w); */
 263   w = glade_xml_get_widget(x, "HostConnectionsCList");
 264   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "HostConnectionsCList"); return; }
 265   for(avlnode = n->edge_tree->head; avlnode; avlnode = avlnode->next)
 266     {
 267       if(((edge_t*)(avlnode->data))->to.node == n)
 268         l[0] = ((edge_t*)(avlnode->data))->from.node->name;
 269       else
 270         l[0] = ((edge_t*)(avlnode->data))->to.node->name;
 271       gtk_clist_append(GTK_CLIST(w), l);
 272     }
 273 }
 274
 275 void on_settings1_activate(GtkMenuItem *mi, gpointer data)
 276 {
 277   GtkWidget *w;
 278   GladeXML *x;
 279
 280   x = glade_xml_new(INTERFACE_FILE, "PropertyBox");
 281   if(x == NULL)
 282     {
 283       log(0, TLOG_ERROR,
 284           _("Could not find widget `%s'"),
 285           "PropertyBox");
 286       return;
 287     }
 288
 289   w = glade_xml_get_widget(x, "PropertyBox");
 290   if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "PropertyBox"); return; }
 291   glade_xml_signal_autoconnect(x);
 292 }
 293
 294 void on_logcontext_clear_activate(GtkMenuItem *mi, gpointer data)
 295 {
 296   GtkWidget *l = glade_xml_get_widget(xml, "Messages");
 297   if(!l) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "Messages"); return; }
 298   gtk_editable_delete_text(GTK_EDITABLE(l), 0, -1); /* Delete from 0 to end of buffer */
 299   log_inited = 0;
 300 }
 301
 302 void on_logcontext_follow_activate(GtkMenuItem *mi, gpointer data)
 303 {
 304   follow_log = !follow_log;
 305 }
 306
 307 void on_messages_button_press_event(GtkWidget *w, GdkEventButton *event, gpointer data)
 308 {
 309   GladeXML *x;
 310   GtkWidget *menu;
 311
 312   if (event->button == 3)
 313     {
 314       x = glade_xml_new(INTERFACE_FILE, "LogContextMenu");
 315       if(x == NULL)
 316         {
 317           log(0, TLOG_ERROR,
 318               _("Could not find widget `%s'"),
 319               "LogContextMenu");
 320           return;
 321         }
 322
 323       menu = glade_xml_get_widget(x, "LogContextMenu");
 324       if(!menu) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "LogContextMenu"); return; }
 325
 326       glade_xml_signal_connect_data(x, "on_logcontext_clear_activate", on_logcontext_clear_activate, (gpointer)x);
 327       glade_xml_signal_connect_data(x, "on_logcontext_follow_activate", on_logcontext_follow_activate, (gpointer)x);
 328       w = glade_xml_get_widget(x, "LogContextFollow");
 329       if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "LogContextFollow"); return; }
 330       GTK_CHECK_MENU_ITEM(w)->active = follow_log;
 331       gnome_popup_menu_do_popup_modal(menu, NULL, NULL, event, NULL);
 332       gtk_widget_destroy(menu);
 333     }
 334 }
 335
 336 void on_canvascontext_shuffle_activate(GtkMenuItem *mi, gpointer data)
 337 {
 338   avl_node_t *avlnode;
 339   double newx, newy;
 340
 341   for(avlnode = node_tree->head; avlnode; avlnode = avlnode->next)
 342     {
 343       newx = ((double)random()) / ((double)RAND_MAX) * 500.0;
 344       newy = ((double)random()) / ((double)RAND_MAX) * 300.0;
 345       ((struct if_node_data*)((node_t *)(avlnode->data))->data)->x = newx;
 346       ((struct if_node_data*)((node_t *)(avlnode->data))->data)->y = newy;
 347
 348       if(!((struct if_node_data*)((node_t*)(avlnode->data)))->visible)
 349         continue;
 350
 351       x[((struct if_node_data*)((node_t*)(avlnode->data))->data)->id] = newx;
 352       y[((struct if_node_data*)((node_t*)(avlnode->data))->data)->id] = newy;
 353     }
 354   inited = 0;
 355   build_graph = 1;
 356 }
 357
 358 void on_canvascontext_keep_drawing_activate(GtkMenuItem *mi, gpointer data)
 359 {
 360   keep_drawing = !keep_drawing;
 361 }
 362
 363 void on_canvascontext_minus50_activate(GtkMenuItem *mi, gpointer data)
 364 {
 365   canvas_zoom *= 0.50;
 366   gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas), canvas_zoom);
 367 }
 368
 369 void on_canvascontext_minus25_activate(GtkMenuItem *mi, gpointer data)
 370 {
 371   canvas_zoom *= 0.75;
 372   gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas), canvas_zoom);
 373 }
 374
 375 void on_canvascontext_minus10_activate(GtkMenuItem *mi, gpointer data)
 376 {
 377   canvas_zoom *= 0.90;
 378   gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas), canvas_zoom);
 379 }
 380
 381 void on_canvascontext_default_activate(GtkMenuItem *mi, gpointer data)
 382 {
 383   canvas_zoom = 1.00;
 384   gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas), 1.00);
 385 }
 386
 387 void on_canvascontext_plus10_activate(GtkMenuItem *mi, gpointer data)
 388 {
 389   canvas_zoom *= 1.10;
 390   gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas), canvas_zoom);
 391 }
 392
 393 void on_canvascontext_plus25_activate(GtkMenuItem *mi, gpointer data)
 394 {
 395   canvas_zoom *= 1.25;
 396   gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas), canvas_zoom);
 397 }
 398
 399 void on_canvascontext_plus50_activate(GtkMenuItem *mi, gpointer data)
 400 {
 401   canvas_zoom *= 1.50;
 402   gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas), canvas_zoom);
 403 }
 404
 405 void on_canvas_button_press_event(GtkWidget *w, GdkEventButton *event, gpointer data)
 406 {
 407   GladeXML *x;
 408   GtkWidget *menu;
 409
 410   if (event->button == 3)
 411     {
 412       x = glade_xml_new(INTERFACE_FILE, "CanvasContextMenu");
 413       if(x == NULL)
 414         {
 415           log(0, TLOG_ERROR,
 416               _("Could not find widget `%s'"),
 417               "CanvasContextMenu");
 418           return;
 419         }
 420
 421       menu = glade_xml_get_widget(x, "CanvasContextMenu");
 422       if(!menu) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "CanvasContextMenu"); return; }
 423
 424       glade_xml_signal_autoconnect(x);
 425       glade_xml_signal_connect_data(x, "on_canvascontext_shuffle_activate", on_canvascontext_shuffle_activate, (gpointer)x);
 426       glade_xml_signal_connect_data(x, "on_canvascontext_keep_drawing_activate", on_canvascontext_keep_drawing_activate, (gpointer)x);
 427       w = glade_xml_get_widget(x, "CanvasContextKeepDrawing");
 428       if(!w) { log(0, TLOG_ERROR, _("Couldn't find widget `%s'"), "CanvasContextKeepDrawing"); return; }
 429       GTK_CHECK_MENU_ITEM(w)->active = keep_drawing;
 430       gnome_popup_menu_do_popup_modal(menu, NULL, NULL, event, NULL);
 431       gtk_widget_destroy(menu);
 432     }
 433 }
 434
 435 void on_nodetree_button_press_event(GtkWidget *w, GdkEventButton *event, gpointer data)
 436 {
 437   GtkCTreeNode *node;
 438   int row, col;
 439   gpointer lt;
 440   GladeXML *x;
 441
 442   gtk_clist_get_selection_info(GTK_CLIST(w), event->x, event->y,
 443                                &row, &col);
 444
 445   node = gtk_ctree_node_nth(GTK_CTREE(w), row);
 446   if(node == NULL)
 447     return;
 448   lt = gtk_ctree_node_get_row_data(GTK_CTREE(w), node);
 449   if(event->type == GDK_2BUTTON_PRESS && event->button == 1)
 450     {
 451       /* Double left click on an item */
 452       if(lt == NULL)
 453         /* this is only a branch, double click wil (un)expand. */
 454         return;
 455
 456       if(GTK_CTREE_ROW(node)->parent == hosts_ctn)
 457         {
 458           x = ((struct if_node_data*)(((node_t*)lt)->data))->hi_xml = glade_xml_new(INTERFACE_FILE, "HostInfoWindow");
 459           if(x == NULL)
 460             {
 461               log(0, TLOG_ERROR,
 462                   _("Could not find widget `%s'"),
 463                   "HostInfoWindow");
 464               return;
 465             }
 466           glade_xml_signal_autoconnect(x);
 467           update_hostinfo_dialog(x, (node_t*)lt);
 468         }
 469       else
 470         {
 471           log(0, TLOG_ERROR,
 472               "WHERE did you click?!");
 473         }
 474       /* so now we have access to all the data we want. */
 475 /*       gldap_show_details(lt); */
 476       return;
 477     }
 478 /*   else */
 479 /*     if (event->button == 3) */
 480 /*       { */
 481 /*         GtkWidget *temp_menu; */
 482 /*         temp_menu = gnome_popup_menu_new(data); */
 483 /*         gnome_popup_menu_do_popup_modal(temp_menu, NULL, NULL, event, NULL); */
 484 /*         gtk_widget_destroy(temp_menu); */
 485 /*       } */
 486 }
 487
 488 void on_exit1_activate(GtkMenuItem *mi, gpointer data)
 489 {
 490   close_network_connections();
 491   gtk_exit(0);
 492 }
 493
 494 void on_info1_activate(GtkMenuItem *mi, gpointer data)
 495 {
 496   GladeXML *x;
 497   x = glade_xml_new(INTERFACE_FILE, "AboutWindow");
 498   if(x == NULL)
 499     {
 500       log(0, TLOG_ERROR,
 501           _("Could not find widget `%s'"),
 502           "AboutWindow");
 503       return;
 504     }
 505 }
 506
 507 int init_interface(void)
 508 {
 509   char *l[1];
 510
 511   glade_gnome_init();
 512
 513   xml = glade_xml_new("pokey.glade", "AppWindow");
 514
 515   if(!xml)
 516     {
 517       log(0, TLOG_ERROR,
 518           _("Something bad happened while creating the interface.\n"));
 519       return -1;
 520     }
 521
 522   nodetree = glade_xml_get_widget(xml, "NodeTree");
 523   if(!nodetree)
 524     {
 525       log(0, TLOG_ERROR,
 526           _("Could not find widget `%s'"),
 527           "NodeTree");
 528       return -1;
 529     }
 530
 531   gtk_clist_freeze(GTK_CLIST(nodetree));
 532   l[0] = _("Hosts");
 533   hosts_ctn = gtk_ctree_insert_node(GTK_CTREE(nodetree),
 534                               NULL, NULL, l, 1,
 535                               NULL, NULL, NULL, NULL,
 536                               FALSE, TRUE);
 537   gtk_clist_thaw(GTK_CLIST(nodetree));
 538
 539   create_canvas();
 540
 541   glade_xml_signal_autoconnect(xml);
 542
 543   log_add_hook(log_gtk);
 544   log_del_hook(log_default);
 545
 546   add_hook("node-add", if_node_add);
 547   add_hook("node-del", if_node_del);
 548   add_hook("subnet-add", if_subnet_add);
 549   add_hook("subnet-del", if_subnet_del);
 550   add_hook("edge-add", if_edge_add);
 551   add_hook("edge-del", if_edge_del);
 552   add_hook("node-visible", if_node_visible);
 553   add_hook("node-invisible", if_node_invisible);
 554
 555   return 0;
 556 }
 557
 558 static gint item_event(GnomeCanvasItem *item, GdkEvent *event, gpointer data)
 559 {
 560   static double item_x, old_x, new_x, item_y, old_y, new_y;
 561   static int dragging = FALSE;
 562   GdkCursor *fleur;
 563   node_t *n;
 564
 565   item_x = event->button.x;
 566   item_y = event->button.y;
 567   gnome_canvas_item_w2i(item->parent, &item_x, &item_y);
 568
 569   switch(event->type)
 570     {
 571     case GDK_BUTTON_PRESS:
 572       switch(event->button.button)
 573         {
 574         case 1:
 575           old_x = item_x;
 576           old_y = item_y;
 577
 578           fleur = gdk_cursor_new(GDK_FLEUR);
 579           gnome_canvas_item_grab(item, GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK, fleur, event->button.time);
 580           gdk_cursor_destroy(fleur);
 581           dragging = TRUE;
 582           break;
 583
 584         default:
 585           break;
 586         }
 587       break;
 588
 589     case GDK_MOTION_NOTIFY:
 590       if(dragging && (event->motion.state & GDK_BUTTON1_MASK))
 591         {
 592           new_x = item_x,
 593           new_y = item_y;
 594           gnome_canvas_item_move(item, new_x - old_x, new_y - old_y);
 595           old_x = new_x;
 596           old_y = new_y;
 597         }
 598       break;
 599
 600     case GDK_BUTTON_RELEASE:
 601       gnome_canvas_item_ungrab(item, event->button.time);
 602       dragging = FALSE;
 603       n = (node_t *)gtk_object_get_user_data(GTK_OBJECT(item));
 604       ((struct if_node_data*)(n->data))->x = item_x;
 605       ((struct if_node_data*)(n->data))->y = item_y;
 606       x[((struct if_node_data*)(n->data))->id] = item_x;
 607       y[((struct if_node_data*)(n->data))->id] = item_y;
 608       build_graph = 1;
 609       break;
 610
 611     default:
 612       break;
 613     }
 614   return FALSE;
 615 }
 616
 617 void if_node_create(node_t *n)
 618 {
 619   GnomeCanvasGroup *group;
 620
 621   group = gnome_canvas_root(GNOME_CANVAS(canvas));
 622   group = GNOME_CANVAS_GROUP(gnome_canvas_item_new(group,
 623                                                    gnome_canvas_group_get_type(),
 624                                                    "x", 0.0,
 625                                                    "y", 0.0,
 626                                                    NULL));
 627
 628   gnome_canvas_item_new(group, gnome_canvas_ellipse_get_type(),
 629                         "x1", -30.0,
 630                         "y1", -08.0,
 631                         "x2", 30.0,
 632                         "y2", 08.0,
 633                         "fill_color_rgba", 0x5f9ea080,
 634                         "outline_color", "black",
 635                         "width_pixels", 0,
 636                         NULL);
 637
 638   gnome_canvas_item_new(group,
 639                         gnome_canvas_text_get_type(),
 640                         "x", 0.0,
 641                         "y", 0.0,
 642                         "text", n->name,
 643                         "anchor", GTK_ANCHOR_CENTER,
 644                         "fill_color", "white",
 645                         "font", "-*-verdana-medium-r-*-*-10-*-*-*-*-*-iso8859-1",
 646                         NULL);
 647
 648   ((struct if_node_data*)(n->data))->item = GNOME_CANVAS_ITEM(group);
 649   ((struct if_node_data*)(n->data))->x = ((struct if_node_data*)(n->data))->y = 0.0;
 650   gtk_object_set_user_data(GTK_OBJECT(group), (gpointer)n);
 651
 652   gtk_signal_connect(GTK_OBJECT(((struct if_node_data*)(n->data))->item), "event", (GtkSignalFunc) item_event, NULL);
 653
 654   gnome_canvas_item_hide(GNOME_CANVAS_ITEM(((struct if_node_data*)(n->data))->item));
 655 }
 656
 657 void if_node_visible(const char *hooktype, va_list ap)
 658 {
 659   int i;
 660   avl_node_t *avlnode;
 661   double newx, newy;
 662   node_t *n = va_arg(ap, node_t*);
 663
 664   if(!((struct if_node_data*)(n->data))->item)
 665     return;
 666
 667   if(((struct if_node_data*)(n->data))->visible)
 668     /* This node is already shown */
 669     return;
 670
 671   ((struct if_node_data*)(n->data))->visible = 1;
 672
 673   newx = 250.0 + 200.0 * sin(number_of_nodes / 10.0 * M_PI);
 674   newy = 150.0 - 100.0 * cos(number_of_nodes / 10.0 * M_PI);
 675   gnome_canvas_item_move(GNOME_CANVAS_ITEM(((struct if_node_data*)(n->data))->item), newx - ((struct if_node_data*)(n->data))->x, newy - ((struct if_node_data*)(n->data))->y);
 676   ((struct if_node_data*)(n->data))->x = newx;
 677   ((struct if_node_data*)(n->data))->y = newy;
 678
 679   for(i = 0, avlnode = node_tree->head; avlnode; avlnode = avlnode->next, i++)
 680     {
 681       if(!((struct if_node_data*)(((node_t*)(avlnode->data))->data))->visible)
 682         continue;
 683
 684       nodes[i] = (node_t *)(avlnode->data);
 685       ((struct if_node_data*)(nodes[i]->data))->id = i;
 686     }
 687   number_of_nodes = i;
 688
 689   gnome_canvas_item_show(GNOME_CANVAS_ITEM(((struct if_node_data*)(n->data))->item));
 690   gnome_canvas_update_now(GNOME_CANVAS(canvas));
 691
 692   /* (Re)start calculations */
 693   inited = 0;
 694   build_graph = 1;
 695 }
 696
 697 void if_node_invisible(const char *hooktype, va_list ap)
 698 {
 699   int i;
 700   avl_node_t *avlnode;
 701   node_t *n = va_arg(ap, node_t*);
 702
 703   if(!((struct if_node_data*)(n->data))->item)
 704     return;
 705
 706   if(!((struct if_node_data*)(n->data))->visible)
 707     /* This node is already invisible */
 708     return;
 709
 710   ((struct if_node_data*)(n->data))->visible = 0;
 711
 712   for(i = 0, avlnode = node_tree->head; avlnode; avlnode = avlnode->next, i++)
 713     {
 714       if(!((struct if_node_data*)((node_t*)(avlnode->data))->data)->visible)
 715         continue;
 716
 717       nodes[i] = (node_t *)(avlnode->data);
 718       ((struct if_node_data*)(nodes[i]->data))->id = i;
 719     }
 720   number_of_nodes = i;
 721
 722   gnome_canvas_item_hide(GNOME_CANVAS_ITEM(((struct if_node_data*)(n->data))->item));
 723   gnome_canvas_update_now(GNOME_CANVAS(canvas));
 724
 725   /* (Re)start calculations */
 726   inited = 0;
 727   build_graph = 1;
 728 }
 729
 730 void if_node_add(const char *hooktype, va_list ap)
 731 {
 732   node_t *n = va_arg(ap, node_t*);
 733   char *l[1];
 734   struct if_node_data *nd;
 735
 736   if(!xml)
 737     return;
 738
 739   nd = xmalloc(sizeof(*nd));
 740   l[0] = n->name;
 741   gtk_clist_freeze(GTK_CLIST(nodetree));
 742   nd->ctn = gtk_ctree_insert_node(GTK_CTREE(nodetree),
 743                                   hosts_ctn, NULL, l, 1,
 744                                   NULL, NULL, NULL, NULL,
 745                                   FALSE, FALSE);
 746   gtk_clist_thaw(GTK_CLIST(nodetree));
 747   gtk_ctree_node_set_row_data(GTK_CTREE(nodetree), nd->ctn, n);
 748
 749   n->data = (void*)nd;
 750
 751   if_node_create(n);
 752   if_node_visible(hooktype, ap);
 753 }
 754
 755 void if_node_del(const char *hooktype, va_list ap)
 756 {
 757   node_t *n = va_arg(ap, node_t*);
 758   struct if_node_data *nd;
 759
 760   nd = (struct if_node_data*)(n->data);
 761   if(nd &&nd->ctn)
 762     {
 763       gtk_clist_freeze(GTK_CLIST(nodetree));
 764       gtk_ctree_remove_node(GTK_CTREE(nodetree), nd->ctn);
 765       gtk_clist_thaw(GTK_CLIST(nodetree));
 766     }
 767
 768   if_node_invisible(hooktype, ap);
 769
 770   free(nd);
 771   n->data = NULL;
 772 }
 773
 774 void if_subnet_add(const char *hooktype, va_list ap)
 775 {
 776   char *l[1];
 777   subnet_t *subnet = va_arg(ap, subnet_t*);
 778   struct if_subnet_data *sd;
 779   GtkCTreeNode *parent;
 780
 781   sd = xmalloc(sizeof(*sd));
 782   l[0] = net2str(subnet);
 783   parent = subnet->owner->data ?
 784     ((struct if_subnet_data*)(subnet->owner->data))->ctn
 785       : NULL;
 786
 787   gtk_clist_freeze(GTK_CLIST(nodetree));
 788   sd->ctn = gtk_ctree_insert_node(GTK_CTREE(nodetree),
 789                                   parent, NULL, l, 1,
 790                                   NULL, NULL, NULL, NULL,
 791                                   TRUE, FALSE);
 792   gtk_clist_thaw(GTK_CLIST(nodetree));
 793   gtk_ctree_node_set_row_data(GTK_CTREE(nodetree), sd->ctn, subnet);
 794
 795   subnet->data = (void*)sd;
 796 }
 797
 798 void if_subnet_del(const char *hooktype, va_list ap)
 799 {
 800   subnet_t *subnet = va_arg(ap, subnet_t*);
 801   struct if_subnet_data *sd;
 802
 803   sd = (struct if_subnet_data*)(subnet->data);
 804   if(sd && sd->ctn)
 805     {
 806       gtk_clist_freeze(GTK_CLIST(nodetree));
 807       gtk_ctree_remove_node(GTK_CTREE(nodetree), sd->ctn);
 808       gtk_clist_thaw(GTK_CLIST(nodetree));
 809     }
 810
 811   free(sd);
 812   subnet->data = NULL;
 813 }
 814
 815 void redraw_edges(void)
 816 {
 817   GnomeCanvasGroup *group;
 818   GnomeCanvasPoints *points;
 819   avl_node_t *avlnode;
 820   edge_t *e;
 821   struct if_node_data *fd, *td;
 822
 823   if(edge_group)
 824     gtk_object_destroy(GTK_OBJECT(edge_group));
 825
 826   group = gnome_canvas_root(GNOME_CANVAS(canvas));
 827   group = GNOME_CANVAS_GROUP(gnome_canvas_item_new(group,
 828                                                    gnome_canvas_group_get_type(),
 829                                                    "x", 0.0,
 830                                                    "y", 0.0,
 831                                                    NULL));
 832
 833   for(avlnode = edge_tree->head; avlnode; avlnode = avlnode->next)
 834     {
 835       e = (edge_t *)avlnode->data;
 836       fd = (struct if_node_data*)(e->from.node->data);
 837       td = (struct if_node_data*)(e->to.node->data);
 838
 839 /*       if(!e->from.node->status.visible || */
 840 /*       !e->to.node->status.visible) */
 841 /*      /\* We shouldn't draw this line *\/ */
 842 /*      continue; */
 843
 844       points = gnome_canvas_points_new(2);
 845
 846       points->coords[0] = fd->x;
 847       points->coords[1] = fd->y;
 848       points->coords[2] = td->x;
 849       points->coords[3] = td->y;
 850       gnome_canvas_item_new(group,
 851                             gnome_canvas_line_get_type(),
 852                             "points", points,
 853                             "fill_color_rgba", 0xe080c080,
 854                             "width_pixels", 2,
 855                             NULL);
 856       gnome_canvas_points_unref(points);
 857     }
 858
 859   gnome_canvas_update_now(GNOME_CANVAS(canvas));
 860
 861   edge_group = group;
 862 }
 863
 864 void if_edge_add(const char *hooktype, va_list ap)
 865 {
 866   redraw_edges();
 867
 868   inited = 0;
 869   build_graph = 1;
 870 }
 871
 872 void if_edge_del(const char *hooktype, va_list ap)
 873 {
 874   redraw_edges();
 875
 876   inited = 0;
 877   build_graph = 1;
 878 }
 879
 880 void if_move_node(node_t *n, double dx, double dy)
 881 {
 882   double newx, newy;
 883
 884   newx = ((struct if_node_data*)(n->data))->x + dx;
 885   newy = ((struct if_node_data*)(n->data))->y + dy;
 886   gnome_canvas_item_move(GNOME_CANVAS_ITEM(((struct if_node_data*)(n->data))->item), newx - ((struct if_node_data*)(n->data))->x, newy - ((struct if_node_data*)(n->data))->y);
 887   ((struct if_node_data*)(n->data))->x = newx;
 888   ((struct if_node_data*)(n->data))->y = newy;
 889 }
 890
 891 #define X_MARGIN 50.0
 892 #define X_MARGIN_BUFFER 25.0
 893 #define Y_MARGIN 20.0
 894 #define Y_MARGIN_BUFFER 10.0
 895
 896 void set_zooming(void)
 897 {
 898   int i;
 899   double minx, miny, maxx, maxy;
 900   static double ominx = 0.0, ominy = 0.0, omaxx = 0.0, omaxy = 0.0;
 901
 902   minx = miny = maxx = maxy = 0.0;
 903   for(i = 0; i < number_of_nodes; i++)
 904     {
 905       if(((struct if_node_data*)(nodes[i]->data))->x < minx)
 906         minx = ((struct if_node_data*)(nodes[i]->data))->x;
 907       else
 908         if(((struct if_node_data*)(nodes[i]->data))->x > maxx)
 909           maxx = ((struct if_node_data*)(nodes[i]->data))->x;
 910
 911       if(((struct if_node_data*)(nodes[i]->data))->y < miny)
 912         miny = ((struct if_node_data*)(nodes[i]->data))->y;
 913       else
 914         if(((struct if_node_data*)(nodes[i]->data))->y > maxy)
 915           maxy = ((struct if_node_data*)(nodes[i]->data))->y;
 916     }
 917
 918   if(minx > ominx - X_MARGIN_BUFFER && ominx > minx)
 919     minx = ominx;
 920   if(maxx < omaxx + X_MARGIN_BUFFER && omaxx < maxx)
 921     maxx = omaxx;
 922   if(miny > ominy - Y_MARGIN_BUFFER && ominy > miny)
 923     miny = ominy;
 924   if(maxy < omaxy + Y_MARGIN_BUFFER && omaxy < maxy)
 925     maxy = omaxy;
 926
 927   ominx = minx; ominy = miny; omaxx = maxx; omaxy = maxy;
 928
 929 /*   ppux = canvas_width / (maxx - minx); */
 930 /*   ppuy = canvas_height / (maxy - miny); */
 931 /*   if(ppux < ppuy) */
 932 /*     ppu = ppux; */
 933 /*   else */
 934 /*     ppu = ppuy; */
 935
 936 /*   gnome_canvas_set_pixels_per_unit(GNOME_CANVAS(canvas), ppu); */
 937   gnome_canvas_set_scroll_region(GNOME_CANVAS(canvas), minx - X_MARGIN, miny - Y_MARGIN, maxx + X_MARGIN, maxy + Y_MARGIN);
 938   gnome_canvas_update_now(GNOME_CANVAS(canvas));
 939 }
 940
 941 double calculate_delta_m(int m)
 942 {
 943   double dedxm, dedym, xmxi, ymyi;
 944   int i;
 945
 946   dedxm = dedym = 0.0;
 947   for(i = 0; i < number_of_nodes; i++)
 948     {
 949       if(i == m)
 950         continue;
 951
 952       xmxi = x[m] - x[i];
 953       ymyi = y[m] - y[i];
 954
 955       dedxm += k[m][i] * (xmxi - ((l[m][i] * xmxi) / sqrt(xmxi * xmxi + ymyi * ymyi)));
 956       dedym += k[m][i] * (xmxi - ((l[m][i] * xmxi) / sqrt(xmxi * xmxi + ymyi * ymyi)));
 957     }
 958
 959   return sqrt(dedxm * dedxm + dedym * dedym);
 960 }
 961
 962 void move_node(int m, double *dx, double *dy)
 963 {
 964   double d2edxm2, d2edym2, d2edxmdym, dedxm, dedym;
 965   double xmxi, ymyi, denominator;
 966   int i;
 967
 968   d2edxm2 = d2edym2 = d2edxmdym = dedxm = dedym = 0.0;
 969   for(i = 0; i < number_of_nodes; i++)
 970     {
 971       if(i == m)
 972         continue;
 973
 974       xmxi = x[m] - x[i];
 975       ymyi = y[m] - y[i];
 976
 977       denominator = pow(sqrt(xmxi * xmxi + ymyi * ymyi), 3.0);
 978
 979       d2edxm2 += k[m][i] * (1 - ((l[m][i] * ymyi * ymyi) / denominator));
 980       d2edxmdym += k[m][i] * l[m][i] * xmxi * ymyi / denominator;
 981       d2edym2 += k[m][i] * (1 - ((l[m][i] * xmxi * xmxi) / denominator));
 982       dedxm += k[m][i] * (xmxi - ((l[m][i] * xmxi) / sqrt(xmxi * xmxi + ymyi * ymyi)));
 983       dedym += k[m][i] * (ymyi - ((l[m][i] * ymyi) / sqrt(xmxi * xmxi + ymyi * ymyi)));
 984     }
 985
 986   denominator = ((d2edxm2 * d2edym2) - (d2edxmdym * d2edxmdym));
 987   *dx = (-(d2edym2 * dedxm) + (d2edxmdym * dedym)) / denominator;
 988   *dy = ((d2edxmdym * dedxm) - (d2edxm2 * dedym)) / denominator;
 989 }
 990
 991 void if_build_graph(void)
 992 {
 993   int i, j, p, max_i;
 994   double delta_m, max_delta_m;
 995   double dx, dy, s, L, min_d, old_x, old_y;
 996   edge_t *e;
 997
 998   if(!keep_drawing)
 999     return;
1000
1001   if(!inited)
1002     {
1003       for(i = 0; i < number_of_nodes; i++)
1004         {
1005           x[i] = ((struct if_node_data*)(nodes[i]->data))->x;
1006           y[i] = ((struct if_node_data*)(nodes[i]->data))->y;
1007         }
1008
1009       /* Initialize Floyd */
1010       for(i = 0; i < number_of_nodes; i++)
1011         {
1012           d[i][i] = 0.0;
1013           for(j = i + 1; j < number_of_nodes; j++)
1014             {
1015               e = lookup_edge(nodes[i], nodes[j]);
1016               if(e)
1017                 d[i][j] = d[j][i] = (double)e->weight;
1018               else
1019                 d[i][j] = d[j][i] = INFINITY;
1020             }
1021         }
1022
1023       /* Floyd's shortest path algorithm */
1024       for(i = 0; i < number_of_nodes; i++)
1025         {
1026           for(j = 0; j < number_of_nodes; j++)
1027             {
1028               if(i == j)
1029                 continue;
1030
1031               if(d[j][i] < INFINITY)
1032                 {
1033                   for(p = 0; p < number_of_nodes; p++)
1034                     {
1035                       if(d[i][j] < INFINITY)
1036                         {
1037                           s = d[j][i] + d[i][p];
1038                           if(s < d[j][p])
1039                             {
1040                               d[j][p] = s;
1041                             }
1042                         }
1043                     }
1044                 }
1045             }
1046         }
1047
1048       min_d = 0.0;
1049       for(i = 0; i < number_of_nodes; i++)
1050         for(j = i + 1; j < number_of_nodes; j++)
1051           if(d[i][j] < min_d && d[i][j] > 0)
1052             min_d = d[i][j];
1053
1054       L = 5.0 / sqrt(min_d + 1.0);
1055
1056       for(i = 0; i < number_of_nodes; i++)
1057         {
1058           for(j = i + 1; j < number_of_nodes; j++)
1059             {
1060               d[i][j] = d[j][i] = sqrt(d[i][j]+1.0);
1061               l[i][j] = l[j][i] = L * d[i][j];
1062               k[i][j] = k[j][i] = K / (d[i][j] * d[i][j]);
1063             }
1064         }
1065
1066       inited = 1;
1067     }
1068
1069   max_delta_m = 0.0;
1070   /* Find node with maximal local energy */
1071   for(i = 0; i < number_of_nodes; i++)
1072     {
1073       delta_m = calculate_delta_m(i);
1074       if(delta_m > max_delta_m)
1075         {
1076           max_delta_m = delta_m;
1077           max_i = i;
1078         }
1079     }
1080
1081   if(max_delta_m <= epsilon)
1082     {
1083       fprintf(stderr, "Graph building is done; max_delta_m = %f\n", max_delta_m);
1084       build_graph = 0;
1085     }
1086   else
1087     {
1088       int iter = 0, maxiter = 20;
1089       delta_m = max_delta_m;
1090       old_x = x[max_i];
1091       old_y = y[max_i];
1092       while(delta_m > epsilon && iter < maxiter)
1093         {
1094           move_node(max_i, &dx, &dy);
1095           x[max_i] += dx;
1096           y[max_i] += dy;
1097           delta_m = calculate_delta_m(max_i);
1098           iter++;
1099         }
1100
1101       if_move_node(nodes[max_i], x[max_i] - old_x, y[max_i] - old_y);
1102
1103       redraw_edges();
1104
1105       set_zooming();
1106     }
1107
1108 /*   build_graph = 0; */
1109 }