gld.c

Path MPICH-V for MPICH the MPI Implementation

/*
  MPICH-V2
  Copyright (C) 2002, 2003 Groupe Cluster et Grid, LRI, Universite de Paris Sud


  This file is part of MPICH-V2.

  MPICH-V2 is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  MPICH-V2 is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with MPICH-V2; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  $Id: gld.c,v 1.1.1.1 2004/01/30 15:49:38 lemarini Exp $
*/
#include <stdlib.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <string.h>
#include <time.h>

#include "gld.h"
#include "glogd.h"

static void gld_new_uid(Gld *gld, name_color *uid, gpointer null)
{
  GtkWidget *uid_dw;
  GtkCList *rlist;

  printf("new uid : %s\n", uid->name);

  gld->uids = g_list_append(gld->uids, uid);
  if( gld->select_uids && ( (uid_dw = gtk_object_get_user_data(GTK_OBJECT(gld->select_uids))) ) )
    {
      rlist = GTK_CLIST( gtk_object_get_user_data( GTK_OBJECT(uid_dw) ) );
      gtk_clist_append(rlist, &(uid->name));
    }
}

static void gld_new_lvl(Gld *gld, name_color *lvl, gpointer null)
{
  GtkWidget *lvl_dw;
  GtkCList *rlist;

  gld->lvls = g_list_append(gld->lvls, lvl);
  if( gld->select_lvls && ( (lvl_dw = gtk_object_get_user_data(GTK_OBJECT(gld->select_lvls))) ) )
    {
      rlist = GTK_CLIST( gtk_object_get_user_data( GTK_OBJECT(lvl_dw) ) );
      gtk_clist_append(rlist, &(lvl->name));
    }
}

static void gld_reset(GLogger *_gld)
{
  Gld *gld = GLD(_gld);
  gtk_clist_clear( GTK_CLIST(gld->mlist) );
}

static void gld_data(GLogger *_gld, msg *m)
{
  char *line[10];
  char lineno_s[64], mid_s[64], addr[128], edate[96], *p;
  struct tm *tp;
  Gld *gld = GLD(_gld);
  int r;
  GtkStyle *st;

  if( !g_list_find( gld->uids, m->uid ) )
    return;

  if( !g_list_find( gld->lvls, m->lvl ) )
    return;

  line[0] = m->uid->name;
  line[1] = m->lvl->name;
  line[2] = m->file;
  line[3] = m->func;
  sprintf(lineno_s, "%d", m->lineno);
  line[4] = lineno_s;
  sprintf(mid_s, "%d", m->mid);
  line[5] = mid_s;
  line[6] = m->dta;

  tp = localtime( (time_t*)&m->edate.tv_sec );
  sprintf(edate, "%s%ld祍", asctime(tp), m->edate.tv_usec);
  for(p = edate; *p != '\n'; p++) ;
  *p = ' ';
  line[7] = edate;

  tp = localtime( (time_t*)&m->rdate.tv_sec );
  line[8] = asctime( tp );
  line[8][strlen(line[8])-1] = 0;
  sprintf(addr, "%s:%d", inet_ntoa(m->from.sin_addr), ntohs(m->from.sin_port));
  line[9] = addr;

  st = gtk_style_copy(GTK_WIDGET(GLOGGER(gld)->logd)->style);
  memcpy( &(st->fg[GTK_WIDGET(GLOGGER(gld)->logd)->state]), &m->lvl->color, sizeof(GdkColor));
  memcpy( &(st->base[GTK_WIDGET(GLOGGER(gld)->logd)->state]), &m->uid->color, sizeof(GdkColor));
  r = gtk_clist_append( GTK_CLIST(gld->mlist), line );
  gtk_clist_set_row_style(GTK_CLIST(gld->mlist), r, st);
  gtk_clist_set_row_data(GTK_CLIST(gld->mlist), r, m);
  gtk_clist_sort(GTK_CLIST(gld->mlist));
  gtk_style_unref(st);
}

static void gld_class_init(GldClass *class)
{
  GLOGGER_CLASS(class)->on_reset = gld_reset;
  GLOGGER_CLASS(class)->on_data  = gld_data;
}

static gboolean gld_delete(GtkWindow *w, GdkEvent *e, gpointer null)
{
  Gld *gld = GLD(gtk_object_get_user_data(GTK_OBJECT(w)));
  gtk_object_destroy( GTK_OBJECT(gld) );
  return FALSE;
}

static void gld_destroy(GtkObject *o, gpointer *null)
{
  Gld *gld = GLD(o);
  gtk_signal_emit_by_name(o, "remove");
  gtk_widget_destroy(gld->window);
}

static void gld_column_display_toggled(GtkToggleButton *togglebutton, Gld *gld)
{
  int i;
  i = (int)gtk_object_get_user_data(GTK_OBJECT(togglebutton));
  gtk_clist_set_column_visibility( GTK_CLIST(gld->mlist),
				   i,
				   gtk_toggle_button_get_active(togglebutton) );
}

static gboolean gld_uid_dw_delete(GtkObject *o, GdkEvent *e, GtkToggleButton *b)
{
  gtk_object_set_user_data(GTK_OBJECT(b), NULL);
  gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(b), FALSE);
  return FALSE;
}

static void gld_uid_dw_in(GtkButton *b, Gld *gld)
{
  GtkCList *llist, *rlist;
  GList *l, *l2;
  char *elt;
  int r;
  int redo = 0;

  llist = GTK_CLIST(gtk_object_get_user_data(GTK_OBJECT(b)));
  rlist = GTK_CLIST(gtk_object_get_user_data(GTK_OBJECT(llist)));
  gtk_clist_freeze(llist); 
  gtk_clist_freeze(rlist);
  /* hack : we eat selection as well as we run in it, so we take the head every time */
  for(l = g_list_first(llist->selection); l; l = g_list_first(llist->selection))
    {
      gtk_clist_get_text( llist, (int)l->data, 0, &elt );
      r = gtk_clist_append( rlist, &elt );
      gtk_clist_remove( llist, (int)l->data );
      gtk_clist_get_text( rlist, r, 0, &elt );

      for(l2 = g_list_first( GLOGGER(gld)->logd->uids ); l2; l2 = g_list_next(l2) )
	if( !strcmp( NC(l2)->name, elt ) )
	  {
	    gld->uids = g_list_append(gld->uids, NC(l2));
	    redo = 1;
	    break;
	  }
    }
  gtk_clist_thaw(llist);
  gtk_clist_thaw(rlist);
  if(redo)
    gld_compute_again(gld);
}

static void gld_uid_dw_out(GtkButton *b, Gld *gld)
{
  GtkCList *llist, *rlist;
  GList *l, *l2;
  char *elt;
  int r;
  int redo = 0;

  rlist = GTK_CLIST(gtk_object_get_user_data(GTK_OBJECT(b)));
  llist = GTK_CLIST(gtk_object_get_user_data(GTK_OBJECT(rlist)));
  gtk_clist_freeze(rlist); 
  gtk_clist_freeze(llist);
  /* hack : we eat selection as well as we run in it, so we take the head every time */
  for(l = g_list_first(rlist->selection); l; l =  g_list_first(rlist->selection))
    {
      gtk_clist_get_text( rlist, (int)l->data, 0, &elt );
      r = gtk_clist_append( llist, &elt );
      gtk_clist_remove( rlist, (int)l->data );
      gtk_clist_get_text( llist, r, 0, &elt);

      for(l2 = g_list_first( GLOGGER(gld)->logd->uids ); l2; l2 = g_list_next(l2) )
	if( !strcmp( NC(l2)->name, elt ) )
	  {
	    gld->uids = g_list_remove(gld->uids, NC(l2));
	    redo = 1;
	    break;
	  }
    }
  gtk_clist_thaw(rlist); 
  gtk_clist_thaw(llist);  
  if(redo)
    gld_compute_again(gld);
}

static void gld_select_uids(GtkToggleButton *b, Gld *gld)
{
  GtkWidget *uid_dw;
  GtkWidget *hbox, *vbbox, *llist, *rlist, *lrarrow, *rlarrow, *lb, *rb;
  char *title_in[1]  = { "UID to display" };
  char *title_out[1] = { "UID not to display" };
  GList *l;
  char *elt[1];

  uid_dw = gtk_object_get_user_data(GTK_OBJECT(b));
  if( gtk_toggle_button_get_active(b) )
    {
      if( !uid_dw )
	{
	  uid_dw = gtk_dialog_new();
	  gtk_window_set_title(GTK_WINDOW(uid_dw), "Select UIDs");
	  gtk_widget_show(uid_dw);
	  
	  hbox = gtk_hbox_new(FALSE, 0);
	  gtk_container_add (GTK_CONTAINER (GTK_DIALOG(uid_dw)->vbox),
			     hbox);
	  gtk_widget_show(hbox);

	  llist = gtk_clist_new_with_titles(1, title_out);
	  gtk_box_pack_start(GTK_BOX(hbox), llist, TRUE, TRUE, 0);
	  gtk_clist_set_selection_mode (GTK_CLIST(llist), GTK_SELECTION_MULTIPLE);
	  gtk_widget_show(llist);
	  
	  vbbox = gtk_vbutton_box_new();
	  gtk_box_pack_start(GTK_BOX(hbox), vbbox, FALSE, FALSE, 0);
	  gtk_vbutton_box_set_layout_default(GTK_BUTTONBOX_SPREAD);
	  gtk_widget_show(vbbox);

	  lrarrow = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
	  gtk_widget_show(lrarrow);
	  lb = gtk_button_new();
	  gtk_container_add(GTK_CONTAINER(lb), lrarrow);
	  gtk_box_pack_start(GTK_BOX(vbbox), lb, FALSE, FALSE, 0);
	  gtk_widget_show(lb);
	  gtk_object_set_user_data(GTK_OBJECT(lb), llist);
	  gtk_signal_connect(GTK_OBJECT(lb), "clicked",
			     GTK_SIGNAL_FUNC(gld_uid_dw_in), gld);

	  rlist = gtk_clist_new_with_titles(1, title_in);
	  gtk_box_pack_start(GTK_BOX(hbox), rlist, TRUE, TRUE, 0);
	  gtk_clist_set_selection_mode (GTK_CLIST(rlist), GTK_SELECTION_MULTIPLE);
	  gtk_widget_show(rlist);

	  rlarrow = gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_OUT);
	  gtk_widget_show(rlarrow);
	  rb = gtk_button_new();
	  gtk_container_add(GTK_CONTAINER(rb), rlarrow);
	  gtk_box_pack_start(GTK_BOX(vbbox), rb, FALSE, FALSE, 0);
	  gtk_widget_show(rb);
	  gtk_object_set_user_data(GTK_OBJECT(rb), rlist);
	  gtk_signal_connect(GTK_OBJECT(rb), "clicked",
			     GTK_SIGNAL_FUNC(gld_uid_dw_out), gld);
	  
	  gtk_object_set_user_data(GTK_OBJECT(rlist), llist);
	  gtk_object_set_user_data(GTK_OBJECT(llist), rlist);

	  gtk_clist_freeze(GTK_CLIST(llist));
	  gtk_clist_freeze(GTK_CLIST(rlist));
	  for(l = g_list_first(GLOGGER(gld)->logd->uids);
	      l;
	      l = g_list_next(l))
	    {
	      elt[0] = NC(l)->name;
	      if( g_list_find( gld->uids, NC(l) ) )
		gtk_clist_append(GTK_CLIST(rlist), elt);
	      else
		gtk_clist_append(GTK_CLIST(llist), elt);		
	    }
	  gtk_clist_thaw(GTK_CLIST(llist));
	  gtk_clist_thaw(GTK_CLIST(rlist));
	  
	  gtk_object_set_user_data(GTK_OBJECT(uid_dw), rlist);

	  gtk_signal_connect( GTK_OBJECT(uid_dw), "delete_event",
			      GTK_SIGNAL_FUNC(gld_uid_dw_delete), b );
	}
    }
  else
    {
      if( uid_dw )
	gtk_widget_destroy(uid_dw);