vis.c

基于chord算法的p2p文件系统。A p2p file system based on chord.

      if (displaysearch) step = true;
    }

    if (words[2] == "step") {
      ConsistentHash::CHID id = strtoull (words[3].c_str (), NULL, 16);
      uint i = find (id);
      ConsistentHash::CHID n = strtoull (words[4].c_str (), NULL, 16);
      nodes[i].search.push_back(n);
      if (words.size () > 5) {
	ConsistentHash::CHID k = strtoull (words[5].c_str (), NULL, 16);
	nodes[i].isearch.push_back(k);
      }
      if (displaysearch) step = true;
    }

    if ((ts >= t) || step) break;
  }

  curtime = ts;

  if (!step && (curtime < t))  { // reached end of file?
    printf ("end of file\n");
    endofsim = curtime;
  } else {
    endofsim = curtime + interval;
  }

  while (endofsim >= bar->upper) {
    bar->upper = 2 * bar->upper;
  }
  bar->value = curtime;
  gtk_adjustment_set_value (bar, curtime);

  draw_ring ();

  return (step);
}
    

// --- UI ----------------------------------------------------------------

unsigned int
check_get_state (void)
{
  unsigned int state = 0;
  for (size_t i = 0; i < NELEM (handlers); i++)
    if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (handlers[i].widget)))
      state |= handlers[i].flag;
  return state;
}

void
check_set_state (unsigned int newstate)
{
  // ONLY set the state of the buttons, do NOT actually toggle anything.
  for (size_t i = 0; i < NELEM (handlers); i++) {
    gtk_signal_handler_block_by_func (GTK_OBJECT (handlers[i].widget),
				      GTK_SIGNAL_FUNC (handlers[i].handler),
				      NULL);
    gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (handlers[i].widget),
				  (newstate & handlers[i].flag));
    gtk_signal_handler_unblock_by_func (GTK_OBJECT (handlers[i].widget),
					GTK_SIGNAL_FUNC (handlers[i].handler),
					NULL);
  }
}

void
init_color_list (char *filename)
{
  GdkColor c;
  color_pair p;
  draw_gc = NULL;
  draw_gc = gdk_gc_new (drawing_area->window);
  assert (draw_gc);
  
  gdk_gc_set_line_attributes (draw_gc, 3,
			      GDK_LINE_SOLID,
			      GDK_CAP_NOT_LAST,
			      GDK_JOIN_MITER);
  cmap = gdk_colormap_get_system ();

  gdk_gc_get_values(draw_gc, &GCValues);

  FILE *cf = fopen (filename, "r");
  if (!cf) { 
    cerr << "couldn't open " << filename << " using default color map\n";
    if (!gdk_color_parse ("red", &c) ||
	!gdk_colormap_alloc_color (cmap, &c, FALSE, TRUE))
      cerr << "couldn't get the color I wanted\n";
    p.c = c;
    p.lat = RAND_MAX;
    lat_map.push_back (p);
    return;
  }
  
  char color[1024];
  unsigned long lat;
  while (fscanf (cf, "%ld %s\n", &lat, color) == 2) {
    if (!gdk_color_parse (color, &c) ||
	!gdk_colormap_alloc_color (cmap, &c, FALSE, TRUE))
      cerr << "couldn't get the color I wanted\n";
    p.c = c;
    p.lat = lat * 1000; //convert from ms to microsec
    lat_map.push_back (p);
  }
  assert (lat_map.size () != 0);
}

void
initgraf ()
{
  courier10 = gdk_font_load ("-*-courier-*-r-*-*-12-*-*-*-*-*-*-*");

  window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

  drawing_area = drawing_area_r = gtk_drawing_area_new();
  gtk_drawing_area_size ((GtkDrawingArea *)drawing_area_r, WINX, WINY);

  GtkWidget *select_all = gtk_button_new_with_label ("Select All");
  GtkWidget *select_none = gtk_button_new_with_label ("Select None");
  GtkWidget *hsep1 = gtk_hseparator_new ();
  GtkWidget *draw_nothing = gtk_button_new_with_label ("Reset");
  GtkWidget *hsep2 = gtk_hseparator_new ();
  last_clicked = gtk_label_new ("                    ");
  total_nodes = gtk_label_new ("                    ");
  for (size_t i = 0; i < NELEM (handlers); i++)
    handlers[i].widget = gtk_check_button_new_with_label (handlers[i].name);
  GtkWidget *hsep3 = gtk_hseparator_new ();
  GtkWidget *hsep4 = gtk_hseparator_new ();

  GtkWidget *in = gtk_button_new_with_label ("Recenter");
  GtkWidget *search = gtk_button_new_with_label ("Step search");
  GtkWidget *run = gtk_button_new_with_label ("Run");
  GtkWidget *step = gtk_button_new_with_label ("Step");
  GtkWidget *quit = gtk_button_new_with_label ("Quit");
  GtkWidget *sep = gtk_vseparator_new ();
  GtkWidget *geo = gtk_button_new_with_label ("Geo. View");
  GtkWidget *dump_to_file = gtk_button_new_with_label ("Save...");
  bar = (GtkAdjustment *) gtk_adjustment_new (0, begin, endofsim, interval, 
					  interval, 100);
  scroll = gtk_hscrollbar_new ((GtkAdjustment *)bar);
  gtk_range_set_update_policy (GTK_RANGE (scroll), GTK_UPDATE_CONTINUOUS);

  //organize things into boxes
  GtkWidget *vbox = gtk_vbox_new (FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), select_all, FALSE, FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), select_none, FALSE, FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hsep1, FALSE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), draw_nothing, FALSE, FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hsep2, FALSE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), last_clicked, FALSE, TRUE, 0);
  for (size_t i = 0; i < NELEM (handlers); i++)
    gtk_box_pack_start (GTK_BOX (vbox), handlers[i].widget, FALSE, FALSE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hsep3, FALSE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), hsep4, FALSE, TRUE, 0);
  gtk_box_pack_start (GTK_BOX (vbox), total_nodes, FALSE, TRUE, 0);

  gtk_box_pack_end (GTK_BOX (vbox), quit, FALSE, FALSE, 0);
  gtk_box_pack_end (GTK_BOX (vbox), run, FALSE, FALSE, 0);
  gtk_box_pack_end (GTK_BOX (vbox), step, FALSE, FALSE, 0);
  gtk_box_pack_end (GTK_BOX (vbox), scroll, FALSE, FALSE, 0);
  gtk_box_pack_end (GTK_BOX (vbox), search, FALSE, FALSE, 0);
  gtk_box_pack_end (GTK_BOX (vbox), dump_to_file, FALSE, FALSE, 0);
  gtk_box_pack_end (GTK_BOX (vbox), geo, FALSE, FALSE, 0);
  gtk_box_pack_end (GTK_BOX (vbox), in, FALSE, FALSE, 0);

  GtkWidget *hbox = gtk_hbox_new (FALSE, 0);
  gtk_box_pack_start (GTK_BOX (hbox), drawing_area_r, TRUE, FALSE, 0);
  gtk_box_pack_start (GTK_BOX (hbox), sep, FALSE, TRUE, 5);
  gtk_box_pack_start (GTK_BOX (hbox), vbox, TRUE, FALSE, 0);

  gtk_container_add(GTK_CONTAINER (window), hbox);

  gtk_signal_connect_object (GTK_OBJECT (select_all), "clicked",
			       GTK_SIGNAL_FUNC (select_all_cb),
			       NULL);
  gtk_signal_connect_object (GTK_OBJECT (select_none), "clicked",
			       GTK_SIGNAL_FUNC (select_none_cb),
			       NULL);
  gtk_signal_connect_object (GTK_OBJECT (draw_nothing), "clicked",
			     GTK_SIGNAL_FUNC (draw_nothing_cb),
			     NULL);
  gtk_signal_connect_object (GTK_OBJECT (search), "clicked",
			       GTK_SIGNAL_FUNC (search_cb),
			       NULL);
  gtk_signal_connect_object (GTK_OBJECT (dump_to_file), "clicked",
			       GTK_SIGNAL_FUNC (dump_cb),
			       NULL);
  gtk_signal_connect_object (GTK_OBJECT (in), "clicked",
			       GTK_SIGNAL_FUNC (zoom_in_cb),
			       NULL);
  gtk_signal_connect_object (GTK_OBJECT (quit), "clicked",
			       GTK_SIGNAL_FUNC (quit_cb),
			       NULL);
  gtk_signal_connect_object (GTK_OBJECT (run), "clicked",
			       GTK_SIGNAL_FUNC (run_cb),
			       NULL);
  gtk_signal_connect_object (GTK_OBJECT (step), "clicked",
			       GTK_SIGNAL_FUNC (step_cb),
			       NULL);
  gtk_signal_connect (GTK_OBJECT (bar), "value_changed",
			       GTK_SIGNAL_FUNC (scroll_cb),
			       NULL);
  gtk_signal_connect_object (GTK_OBJECT (geo), "clicked",
			     GTK_SIGNAL_FUNC (geo_cb),
			     NULL);

  for (size_t i = 0; i < NELEM (handlers); i++) 
    gtk_signal_connect_object (GTK_OBJECT (handlers[i].widget), "toggled",
			       GTK_SIGNAL_FUNC (handlers[i].handler),
			       NULL);

  gtk_signal_connect (GTK_OBJECT (window), "delete_event",
		      GTK_SIGNAL_FUNC (delete_event), NULL);  
  gtk_signal_connect (GTK_OBJECT (window), "key_release_event",
		      GTK_SIGNAL_FUNC (key_release_event), NULL);
  gtk_widget_set_events (window, GDK_KEY_RELEASE_MASK);
  
  gtk_signal_connect (GTK_OBJECT (drawing_area_r), "expose_event",
		      (GtkSignalFunc) expose_event, NULL);
  gtk_signal_connect (GTK_OBJECT(drawing_area_r),"configure_event",
		      (GtkSignalFunc) configure_event, NULL);
  gtk_signal_connect (GTK_OBJECT (drawing_area_r), "button_press_event",
		      (GtkSignalFunc) button_down_event,
		      NULL);

  gtk_widget_set_events (drawing_area_r, GDK_EXPOSURE_MASK
			 | GDK_LEAVE_NOTIFY_MASK
			 | GDK_BUTTON_PRESS_MASK
			 | GDK_POINTER_MOTION_MASK
			 | GDK_POINTER_MOTION_HINT_MASK);

  gtk_widget_show (drawing_area_r);

  gtk_widget_show (select_all);
  gtk_widget_show (select_none);
  gtk_widget_show (draw_nothing);
  for (size_t i = 0; i < NELEM (handlers); i++)
    gtk_widget_show (handlers[i].widget);
  gtk_widget_show (last_clicked);
  gtk_widget_show (total_nodes);
  gtk_widget_show (in);
  gtk_widget_show (dump_to_file);
  gtk_widget_show (geo);
  gtk_widget_show (search);
  gtk_widget_show (quit);
  gtk_widget_show (run);
  gtk_widget_show (step);
  gtk_widget_show (sep);
  gtk_widget_show (hsep1);
  gtk_widget_show (hsep2);
  gtk_widget_show (hsep3);
  gtk_widget_show (hsep4);
  gtk_widget_show (hbox);
  gtk_widget_show (vbox);
  gtk_widget_show (scroll);

  gtk_widget_show (window);

  init_color_list (color_file);

  if (!gdk_color_parse ("red", &red) ||
      !gdk_colormap_alloc_color (cmap, &red, FALSE, TRUE))
    cerr << "Couldn't allocate search color red\n";

  if (!gdk_color_parse ("green", &search_color) ||
      !gdk_colormap_alloc_color (cmap, &search_color, FALSE, TRUE))
    cerr << "Couldn't allocate search color maroon\n";
}


// --- UI events ---------------------------------------------------------------

void
draw_toggle_cb (GtkWidget *widget, gpointer data)
{

  // Set the state of all the selected nodes to match what the button says.
  bool active = false;
  unsigned int flag = 0;
  // xxx Shouldn't we be comparing "widget" to "check_immed_succ"?
  //     Empircally, no, this is what works. Weird.
  for (size_t i = 0; i < NELEM (handlers); i++) {
    if (data == handlers[i].widget) {
      active = gtk_toggle_button_get_active
	(GTK_TOGGLE_BUTTON (handlers[i].widget));
      flag = handlers[i].flag;
      break;
    }
  }

  for (uint i = 0; i < nodes.size (); i++) {
    if (nodes[i].selected) {
      if (active)
	nodes[i].draw |= flag; 
      else
	nodes[i].draw &= ~flag;
    }
  }
  draw_ring ();
}

void 
select_all_cb (GtkWidget *widget, gpointer data) 
{
  for (uint i = 0; i < nodes.size (); i++) {
    nodes[i].selected = true;
  }
  draw_ring ();
}

void 
select_none_cb (GtkWidget *widget,
	        gpointer data) 
{
  for (uint i = 0; i < nodes.size (); i++) {
    nodes[i].selected = false;
  }
  draw_ring ();
}

void
search_cb (GtkWidget *widget, gpointer data)
{
  displaysearch = !displaysearch;
}

void
draw_nothing_cb (GtkWidget *widget, gpointer data)
{
  for (uint i = 0; i < nodes.size (); i++) {
    nodes[i].selected = false;
    nodes[i].highlight = false;
    nodes[i].draw = 0;
    nodes[i].search.clear ();
  }
  check_set_state (0);
  draw_ring ();
}

void
dump_cb (GtkWidget *widget, gpointer data)
{
  GdkPixbuf *pbuf = gdk_pixbuf_get_from_drawable (NULL,
						  pixmap,
						  NULL,
						  0,0,
						  0,0,
						  -1, -1);
  
  gdk_pixbuf_save (pbuf, "vis.jpeg", "jpeg", NULL, "quality", "100", NULL);
}

void
geo_cb (GtkWidget *widget, gpointer data)
{
  ggeo = !ggeo;
  redraw ();
}

void
zoom_in_cb (GtkWidget *widget, gpointer data)
{
  recenter ();
  redraw ();
}

gint
key_release_event (GtkWidget *widget, GdkEventKey *event, gpointer data)
{
  // warnx << "key pressed " << event->keyval << "\n";
  switch (event->keyval) {
  case 'n':
    {
      doevent (curtime + interval);
      break;
    }
  case 'q':
  case 'Q':
    quit_cb (NULL, NULL);
    break;
  default:
    break;
  }

  return (TRUE);
}


gint 
delete_event(GtkWidget *widget, GdkEvent  *event, gpointer   data )
{
  gtk_exit (0);
  return (FALSE);
}


/* Create a new backing pixmap of the appropriate size */
static gint
configure_event (GtkWidget *widget, GdkEventConfigure *event)
{
  if (pixmap)
    gdk_pixmap_unref(pixmap);
  
  pixmap = gdk_pixmap_new(widget->window,
			  widget->allocation.width,
			  widget->allocation.height,
			  -1);
  gdk_draw_rectangle (pixmap,
		      widget->style->white_gc,
		      TRUE,
		      0, 0,
		      widget->allocation.width,
		      widget->allocation.height);
  
  return TRUE;
}

/* Redraw the screen from the backing pixmap */
static gint
expose_event (GtkWidget *widget, GdkEventExpose *event)
{
  gdk_draw_pixmap(widget->window,
		  widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
		  pixmap,
		  event->area.x, event->area.y,
		  event->area.x, event->area.y,
		  event->area.width, event->area.height);
  
  return FALSE;
}

static gint 
button_down_event (GtkWidget *widget, GdkEventButton *event, gpointer data) 
{
  ConsistentHash::CHID ID = xy_to_ID ((int)event->x,(int)event->y);
  uint i = find (ID);
  if (event->button == 2) // middle button
    nodes[i].highlight = !nodes[i].highlight;
  else {
    nodes[i].selected = !nodes[i].selected;
    if (nodes[i].selected)
      check_set_state (nodes[i].draw);
  }

  char hosts[1024];
  sprintf (hosts, "%64qx", nodes[i].id);

  gtk_label_set_text (GTK_LABEL (last_clicked), hosts);
  draw_ring ();
  return TRUE;
}

void
run_cb (GtkWidget *widget, gpointer data)
{
  while (curtime < endofsim) {
    if (doevent (curtime + interval))
      return;
  }
}

void
step_cb (GtkWidget *widget, gpointer data)
{
  (void) doevent (curtime + interval);
}

void
scroll_cb (GtkAdjustment *adj, gpointer data)
{
  ulong t;

  if (adj->value < curtime) {
    draw_nothing_cb ((GtkWidget *) adj, data);
    in.seekg (0);
    curtime = 0;
  }
  t = (ulong) (adj->value);
  (void) doevent (t);
}

void 
quit_cb (GtkWidget *widget, gpointer data)
{
  gtk_exit (0);
}

void
usage ()
{
   cerr << "Usage: vis [-i] [-a <step>] <sim-file>" << endl;
}

int
main (int argc, char** argv) 
{
  string sim_file;
  color_file = ".viscolors";

  int ch;
  while ((ch = getopt (argc, argv, "a:i")) != -1) {
    switch (ch) {
    case 'a':
      {
	interval = atoi (optarg);
	argc -= 2;
	argv += 2;
      }
      break;
    case 'i':
      {
	drawids = true;
	argc--;
	argv++;
      }
      break;
    default:
      usage ();
    }
  };

  gtk_init (&argc, &argv);

  if (argc < 2) {
    usage ();
    exit (-1);
  } else {
    sim_file = argv[1];
  }

  in.open(argv[1]);
  if(!in) {
    cerr << "Error: no file " << argv[1] << endl;
    exit (-1);
  }

  initgraf ();
  gtk_main ();
}