Logo Search packages:      
Sourcecode: slurm-llnl version File versions  Download package

grid.c

/****************************************************************************\
 *  grid.c - put display grid info here
 *****************************************************************************
 *  Copyright (C) 2002-2006 The Regents of the University of California.
 *  Produced at Lawrence Livermore National Laboratory (cf, DISCLAIMER).
 *  Written by Danny Auble <da@llnl.gov>, et. al.
 *  UCRL-CODE-226842.
 *  
 *  This file is part of SLURM, a resource management program.
 *  For details, see <http://www.llnl.gov/linux/slurm/>.
 *  
 *  SLURM 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.
 *
 *  In addition, as a special exception, the copyright holders give permission 
 *  to link the code of portions of this program with the OpenSSL library under
 *  certain conditions as described in each individual source file, and 
 *  distribute linked combinations including the two. You must obey the GNU 
 *  General Public License in all respects for all of the code used other than 
 *  OpenSSL. If you modify file(s) with this exception, you may extend this 
 *  exception to your version of the file(s), but you are not obligated to do 
 *  so. If you do not wish to do so, delete this exception statement from your
 *  version.  If you delete this exception statement from all source files in 
 *  the program, then also delete it here.
 *  
 *  SLURM 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 SLURM; if not, write to the Free Software Foundation, Inc.,
 *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA.
\*****************************************************************************/
#include "sview.h"

List grid_button_list = NULL;
List blinking_button_list = NULL;

char *sview_colors[] = {"#0000FF", "#00FF00", "#00FFFF", "#FFFF00", 
                  "#FF0000", "#4D4DC6", "#F09A09", "#BDFA19",
                  "#715627", "#6A8CA2", "#4C7127", "#25B9B9",
                  "#A020F0", "#8293ED", "#FFA500", "#FFC0CB",
                  "#8B6914", "#18A24E", "#F827FC", "#B8A40C"};
int sview_colors_cnt = 20;

GStaticMutex blinking_mutex = G_STATIC_MUTEX_INIT;


static void _open_node(GtkWidget *widget, GdkEventButton *event, 
                   grid_button_t *grid_button)
{
      GError *error = NULL;
      char title[100];
      ListIterator itr = NULL;
      popup_info_t *popup_win = NULL;

#ifdef HAVE_BG
      snprintf(title, 100, 
             "Info about base partition %s", grid_button->node_name);
#else
      snprintf(title, 100, "Info about node %s", grid_button->node_name);
#endif
      itr = list_iterator_create(popup_list);
      while((popup_win = list_next(itr))) {
            if(popup_win->spec_info)
                  if(!strcmp(popup_win->spec_info->title, title)) {
                        break;
                  } 
      }
      list_iterator_destroy(itr);

      if(!popup_win) {
            popup_win = create_popup_info(INFO_PAGE, NODE_PAGE, title);
            popup_win->spec_info->search_info->gchar_data =
                  g_strdup(grid_button->node_name);
            if (!g_thread_create((gpointer)popup_thr, popup_win,
                             FALSE, &error))
            {
                  g_printerr ("Failed to create grid popup thread: "
                            "%s\n", 
                            error->message);
                  return;
            }     
      } else
            gtk_window_present(GTK_WINDOW(popup_win->popup));
      return;
}

#ifdef HAVE_BG
static void _open_block(GtkWidget *widget, GdkEventButton *event, 
                  grid_button_t *grid_button)
{
      GError *error = NULL;
      char title[100];
      ListIterator itr = NULL;
      popup_info_t *popup_win = NULL;

      snprintf(title, 100, 
             "Info about block containing %s", grid_button->node_name);

      itr = list_iterator_create(popup_list);
      while((popup_win = list_next(itr))) {
            if(popup_win->spec_info)
                  if(!strcmp(popup_win->spec_info->title, title)) {
                        break;
                  } 
      }
      list_iterator_destroy(itr);

      if(!popup_win) {
            popup_win = create_popup_info(INFO_PAGE, BLOCK_PAGE, title);
            popup_win->spec_info->search_info->search_type =
                  SEARCH_BLOCK_NODENAME;
            popup_win->spec_info->search_info->gchar_data =
                  g_strdup(grid_button->node_name);
            if (!g_thread_create((gpointer)popup_thr, popup_win,
                             FALSE, &error))
            {
                  g_printerr ("Failed to create block "
                            "grid popup thread: %s\n", 
                            error->message);
                  return;
            }     
      } else
            gtk_window_present(GTK_WINDOW(popup_win->popup));
      return;
}
#endif

/* 
 * Comparator used for sorting buttons
 * 
 * returns: -1: button_a->inx > button_b->inx   
 *           0: rec_a == rec_b
 *           1: rec_a < rec_b
 * 
 */
static int _sort_button_inx(grid_button_t *button_a, grid_button_t *button_b)
{
      int inx_a = button_a->inx;
      int inx_b = button_b->inx;
      
      if (inx_a < inx_b)
            return -1;
      else if (inx_a > inx_b)
            return 1;
      return 0;
}

void _put_button_as_down(grid_button_t *grid_button, int state)
{
      GtkWidget *image = NULL;
      GdkColor color;

      if(GTK_IS_EVENT_BOX(grid_button->button)) {
            return;
      }
      gtk_widget_destroy(grid_button->button);        
            
      grid_button->button = gtk_event_box_new();
      gtk_tooltips_set_tip(grid_button->tip,
                       grid_button->button,
                       grid_button->node_name,
                       "click for node stats");
      gtk_widget_set_size_request(grid_button->button, 10, 10);
      gtk_event_box_set_above_child(GTK_EVENT_BOX(grid_button->button),
                              FALSE);
      g_signal_connect(G_OBJECT(grid_button->button),
                   "button-press-event",
                   G_CALLBACK(_open_node),
                   grid_button);
      if(grid_button->table) 
            gtk_table_attach(grid_button->table, grid_button->button,
                         grid_button->table_x,
                         (grid_button->table_x+1), 
                         grid_button->table_y,
                         (grid_button->table_y+1),
                         GTK_SHRINK, GTK_SHRINK,
                         1, 1);
      
      gdk_color_parse("black", &color);
      gtk_widget_modify_bg(grid_button->button, 
                       GTK_STATE_NORMAL, &color);
      gdk_color_parse("white", &color);
      gtk_widget_modify_bg(grid_button->button, 
                       GTK_STATE_PRELIGHT, &color);
      if(state == NODE_STATE_DRAIN)
            image = gtk_image_new_from_stock(GTK_STOCK_DIALOG_ERROR,
                                     GTK_ICON_SIZE_SMALL_TOOLBAR);
      else 
            image = gtk_image_new_from_stock(GTK_STOCK_CANCEL,
                                     GTK_ICON_SIZE_SMALL_TOOLBAR);
      gtk_container_add(GTK_CONTAINER(grid_button->button), image);
      gtk_widget_show_all(grid_button->button);
      return;     
}

void _put_button_as_up(grid_button_t *grid_button)
{
      if(GTK_IS_BUTTON(grid_button->button)) {
            return;
      }
      gtk_widget_destroy(grid_button->button);        
      grid_button->button = gtk_button_new();
      gtk_widget_set_size_request(grid_button->button, 10, 10);
      gtk_tooltips_set_tip(grid_button->tip,
                       grid_button->button,
                       grid_button->node_name,
                       "click for node stats");
      g_signal_connect(G_OBJECT(grid_button->button), 
                   "button-press-event",
                   G_CALLBACK(_open_node),
                   grid_button);
      if(grid_button->table) 
            gtk_table_attach(grid_button->table, grid_button->button,
                         grid_button->table_x,
                         (grid_button->table_x+1), 
                         grid_button->table_y,
                         (grid_button->table_y+1),
                         GTK_SHRINK, GTK_SHRINK,
                         1, 1);
      gtk_widget_show_all(grid_button->button);
      return;
}

#ifdef HAVE_BG
static int _block_in_node(int *bp_inx, int inx)
{
      int j=0;
      if(bp_inx[j] >= 0) {
            if ((bp_inx[j] == inx)
                && (bp_inx[j+1] == inx))
                  return 1;
      }
      return 0;
}
#endif

extern void destroy_grid_button(void *arg)
{
      grid_button_t *grid_button = (grid_button_t *)arg;
      if(grid_button) {
            if(grid_button->button) {
                  gtk_widget_destroy(grid_button->button);
                  grid_button->button = NULL;
            }
            xfree(grid_button->node_name);
            xfree(grid_button);
      }
}

/* we don't set the call back for the button here because sometimes we
 * need to get a different call back based on what we are doing with
 * the button, an example of this would be in
 * add_extra_bluegene_buttons were the small block buttons do
 * something different than they do regularly
 */

extern grid_button_t *create_grid_button_from_another(
      grid_button_t *grid_button, char *name, int color_inx)
{
      grid_button_t *send_grid_button = NULL;
      GdkColor color;
      uint16_t node_base_state;

      if(!grid_button || !name)
            return NULL;
      if(color_inx >= 0)
            color_inx %= sview_colors_cnt;
                  
      send_grid_button = xmalloc(sizeof(grid_button_t));
      memcpy(send_grid_button, grid_button, sizeof(grid_button_t));
      node_base_state = send_grid_button->state & NODE_STATE_BASE;
      /* need to set the table to empty because we will want to fill
         this into the new table later */
      send_grid_button->table = NULL;
      if((color_inx >= 0) && node_base_state == NODE_STATE_DOWN) {
            GtkWidget *image = gtk_image_new_from_stock(
                  GTK_STOCK_CANCEL,
                  GTK_ICON_SIZE_SMALL_TOOLBAR);
            send_grid_button->button = gtk_event_box_new();
            gtk_event_box_set_above_child(
                  GTK_EVENT_BOX(send_grid_button->button),
                  FALSE);
            gdk_color_parse("black", &color);
            gtk_widget_modify_bg(send_grid_button->button, 
                             GTK_STATE_NORMAL, &color);
            gdk_color_parse("white", &color);
            gtk_widget_modify_bg(send_grid_button->button, 
                             GTK_STATE_PRELIGHT, &color);
            gtk_container_add(
                  GTK_CONTAINER(send_grid_button->button),
                  image);
      } else if((color_inx >= 0)
              && send_grid_button->state & NODE_STATE_DRAIN) {
            GtkWidget *image = gtk_image_new_from_stock(
                  GTK_STOCK_DIALOG_ERROR,
                  GTK_ICON_SIZE_SMALL_TOOLBAR);
            
            send_grid_button->button = gtk_event_box_new();
            gtk_event_box_set_above_child(
                  GTK_EVENT_BOX(send_grid_button->button),
                  FALSE);
            gdk_color_parse("black", &color);
            gtk_widget_modify_bg(send_grid_button->button, 
                             GTK_STATE_NORMAL, &color);
            gdk_color_parse("white", &color);
            gtk_widget_modify_bg(send_grid_button->button, 
                             GTK_STATE_PRELIGHT, &color);
            gtk_container_add(
                  GTK_CONTAINER(send_grid_button->button),
                  image);           
      } else {
            send_grid_button->button = gtk_button_new();
            if(color_inx >= 0)
                  gdk_color_parse(sview_colors[color_inx], &color);
            else
                  gdk_color_parse("white", &color);
            gtk_widget_modify_bg(send_grid_button->button, 
                             GTK_STATE_NORMAL, &color);
      }
      gtk_widget_set_size_request(send_grid_button->button, 10, 10);
      send_grid_button->tip = gtk_tooltips_new();
      
      send_grid_button->node_name = xstrdup(name);
      
      gtk_tooltips_set_tip(send_grid_button->tip,
                       send_grid_button->button,
                       send_grid_button->node_name,
                       "click for node stats");
      if(color_inx >= 0)
            send_grid_button->color = sview_colors[color_inx];
      else
            send_grid_button->color = "white";
      return send_grid_button;
}

extern char *change_grid_color(List button_list, int start, int end,
                         int color_inx)
{
      ListIterator itr = NULL;
      grid_button_t *grid_button = NULL;
      uint16_t node_base_state;
      GdkColor color;

      if(!button_list)
            return NULL;

      itr = list_iterator_create(button_list);
      color_inx %= sview_colors_cnt;
      gdk_color_parse(sview_colors[color_inx], &color);
      while((grid_button = list_next(itr))) {
            if ((grid_button->inx < start)
                ||  (grid_button->inx > end)) 
                  continue;
            node_base_state = grid_button->state & NODE_STATE_BASE;
            if (node_base_state == NODE_STATE_DOWN) {
                  _put_button_as_down(grid_button, NODE_STATE_DOWN);
            } else if (grid_button->state & NODE_STATE_DRAIN) {
                  _put_button_as_down(grid_button, NODE_STATE_DRAIN);
            } else {
                  _put_button_as_up(grid_button);
                  grid_button->color = sview_colors[color_inx];
                  gtk_widget_modify_bg(grid_button->button, 
                                   GTK_STATE_NORMAL, &color);
            }
      }
      list_iterator_destroy(itr);
      return sview_colors[color_inx];
}

extern void get_button_list_from_main(List *button_list, int start, int end,
                              int color_inx)
{
      ListIterator itr = NULL;
      ListIterator button_itr = NULL;
      grid_button_t *grid_button = NULL;
      grid_button_t *send_grid_button = NULL;
      
      if(!*button_list)
            *button_list = list_create(destroy_grid_button);
      
      color_inx %= sview_colors_cnt;
      
      itr = list_iterator_create(grid_button_list);
      while((grid_button = list_next(itr))) {
            if ((grid_button->inx < start)
                ||  (grid_button->inx > end)) 
                  continue;
            button_itr = list_iterator_create(*button_list);
            while((send_grid_button = list_next(button_itr))) {
                  if(send_grid_button->inx == grid_button->inx)
                        break;
            }
            list_iterator_destroy(button_itr);
            if(send_grid_button)
                  continue;
            
            send_grid_button = create_grid_button_from_another(
                  grid_button, grid_button->node_name, color_inx);
            if(send_grid_button) {
                  g_signal_connect(G_OBJECT(send_grid_button->button),
                   "button-press-event",
                   G_CALLBACK(_open_node),
                   send_grid_button);
                  list_append(*button_list, send_grid_button);
            }
      }
      list_iterator_destroy(itr);
      return;
}

extern List copy_main_button_list()
{
      ListIterator itr = NULL;
      grid_button_t *grid_button = NULL;
      grid_button_t *send_grid_button = NULL;
      List button_list = list_create(destroy_grid_button);
      
      itr = list_iterator_create(grid_button_list);
      while((grid_button = list_next(itr))) {
            send_grid_button = create_grid_button_from_another(
                  grid_button, grid_button->node_name, -1);
            if(send_grid_button) {
                  g_signal_connect(G_OBJECT(send_grid_button->button),
                               "button-press-event",
                               G_CALLBACK(_open_node),
                               send_grid_button);
                  list_append(button_list, send_grid_button);
            }
      }
      list_iterator_destroy(itr);
      return button_list;
}

#ifdef HAVE_BG
extern void add_extra_bluegene_buttons(List *button_list, int inx, 
                               int *color_inx)
{
      node_select_info_msg_t *node_select_ptr = NULL;
      bg_info_record_t *bg_info_ptr = NULL;
      int error_code = SLURM_SUCCESS;
      ListIterator itr = NULL;
      grid_button_t *grid_button = NULL;
      grid_button_t *send_grid_button = NULL;
      int i=0;
      char *nodes = NULL;
      char tmp_nodes[256];
      int found = 0;
      int coord_y=0;
      
      error_code = get_new_info_node_select(&node_select_ptr, 0);
      
      if (error_code != SLURM_SUCCESS 
          && error_code != SLURM_NO_CHANGE_IN_DATA) {
            return;
      }
      
      if(!*button_list) 
            *button_list = list_create(NULL);
      
      *color_inx %= sview_colors_cnt;
      
      itr = list_iterator_create(grid_button_list);
      while((grid_button = list_next(itr))) {
            if (grid_button->inx == inx)
                  break;
      }
      list_iterator_destroy(itr);
      
      if(!grid_button)
            return;

      /* remove all (if any) buttons pointing to this node since we
         will be creating all of them */

      itr = list_iterator_create(*button_list);
      while((send_grid_button = list_next(itr))) {
            if(send_grid_button->inx == grid_button->inx)
                  list_remove(itr);
      }
      list_iterator_destroy(itr);
      
      for (i=0; i < node_select_ptr->record_count; i++) {
            bg_info_ptr = &node_select_ptr->bg_info_array[i];
            if(!_block_in_node(bg_info_ptr->bp_inx, inx))
                  continue;
            found = 1;
            nodes = bg_info_ptr->nodes;               
            if(bg_info_ptr->ionodes) {
                  sprintf(tmp_nodes, "%s[%s]", nodes,
                        bg_info_ptr->ionodes);
                  nodes = tmp_nodes;
            }
            send_grid_button = create_grid_button_from_another(
                  grid_button, nodes, *color_inx);
            if(send_grid_button) {
                  send_grid_button->table_x = 0;
                  send_grid_button->table_y = coord_y++;
                  g_signal_connect(
                        G_OBJECT(send_grid_button->button),
                        "button-press-event",
                        G_CALLBACK(_open_block),
                        send_grid_button);
                  
                  list_append(*button_list, send_grid_button);
                  (*color_inx)++;
            }
      }
      if(!found) {
            send_grid_button = create_grid_button_from_another(
                  grid_button, grid_button->node_name, *color_inx);
            if(send_grid_button) {
                  send_grid_button->table_x = 0;
                  send_grid_button->table_y = coord_y++;
                  g_signal_connect(
                        G_OBJECT(send_grid_button->button),
                        "button-press-event",
                        G_CALLBACK(_open_node),
                        send_grid_button);
                  
                  list_append(*button_list, send_grid_button);
                  (*color_inx)++;
            }
      }

}
#endif

extern void add_extra_cr_buttons(List *button_list, node_info_t *node_ptr)
{
      /* FIXME: this is here for consumable resources "multi-core"
         and what not to add buttons for each.  This needs to be added
         when HP is done with the multi-core code. */
      return;
}

extern void put_buttons_in_table(GtkTable *table, List button_list)
{
      int table_x=0, table_y=0;
#ifndef HAVE_BG
      int coord_x=0, coord_y=0;
#endif
      grid_button_t *grid_button = NULL;
      ListIterator itr = NULL;
      int node_count = list_count(button_list);
      
      list_sort(button_list, (ListCmpF) _sort_button_inx);
      
#ifdef HAVE_BG
      node_count = DIM_SIZE[X];
      table_x = DIM_SIZE[X] + DIM_SIZE[Z];
      table_y = (DIM_SIZE[Z] * DIM_SIZE[Y]) + DIM_SIZE[Y];
#else
      if(node_count < 50) {
            table_x = 1;
      } else if(node_count < 500) {
            table_x = 10;
      } else {
            table_x=20;
      }
      table_y = node_count/table_x;
      table_y++;
#endif
      //g_print("the table size is y=%d x=%d\n", table_y, table_x);
      gtk_table_resize(table, table_y, table_x);
      itr = list_iterator_create(button_list);
      while((grid_button = list_next(itr))) {
#ifdef HAVE_BG
            grid_button->table = table;
            gtk_table_attach(table, grid_button->button,
                         grid_button->table_x, 
                         (grid_button->table_x+1),
                         grid_button->table_y,
                         (grid_button->table_y+1),
                         GTK_SHRINK, GTK_SHRINK,
                         1, 1);
            if(!grid_button->table_x)
                  gtk_table_set_row_spacing(table, 
                                      grid_button->table_y, 5);
#else
            grid_button->table = table;
            grid_button->table_x = coord_x;
            grid_button->table_y = coord_y;
            gtk_table_attach(table, grid_button->button,
                         coord_x, (coord_x+1), coord_y, (coord_y+1),
                         GTK_SHRINK, GTK_SHRINK,
                         1, 1);
            
            coord_x++;
            
            if(coord_x == table_x) {
                  coord_x = 0;
                  coord_y++;
                  if(!(coord_y%10)) {
                        gtk_table_set_row_spacing(
                              table, coord_y-1, 5);
                  }
                  
            }
            
            if(coord_y == table_y)
                  break;
            
            if(coord_x && !(coord_x%10)) {
                  gtk_table_set_col_spacing(table,
                                      coord_x-1,
                                      5);
            }
#endif
      }
      list_iterator_destroy(itr);

      gtk_widget_show_all(GTK_WIDGET(table));
}

extern int get_system_stats(GtkTable *table)
{
      int error_code = SLURM_SUCCESS;
      node_info_msg_t *node_info_ptr = NULL;
      List node_list = NULL;
      int changed = 1;
      static GtkWidget *label = NULL;
      char error_char[100];
      
      if(label)
            gtk_widget_destroy(label);

      if((error_code = get_new_info_node(&node_info_ptr, force_refresh))
         == SLURM_NO_CHANGE_IN_DATA) { 
            changed = 0;
      } else if (error_code != SLURM_SUCCESS) {       
            snprintf(error_char, 100, "slurm_load_node: %s\n",
                   slurm_strerror(error_code));
            label = gtk_label_new(error_char);
            gtk_table_attach_defaults(table, label, 0, 1, 0, 1);
            gtk_widget_show(label);
            
            return SLURM_ERROR;
      }

      ba_init(node_info_ptr); 
      if(grid_button_list)
            return SLURM_SUCCESS;
      grid_button_list = list_create(destroy_grid_button);
      node_list = create_node_info_list(node_info_ptr, changed);
      setup_grid_table(main_grid_table, grid_button_list, node_list);
      gtk_widget_show_all(GTK_WIDGET(main_grid_table));
      return SLURM_SUCCESS;
}

extern int setup_grid_table(GtkTable *table, List button_list, List node_list)
{
      int error_code = SLURM_SUCCESS;
      int x=0, table_x=0, table_y=0;
      int coord_x=0, coord_y=0, i=0;
      grid_button_t *grid_button = NULL;
      int node_count = 0;
      ListIterator itr = NULL;
      sview_node_info_t *sview_node_info_ptr = NULL;
#ifdef HAVE_BG
      int y=0, z=0, x_offset=0, y_offset=0;
#endif

      if(!node_list) {
            g_print("setup_grid_table: no node_list given\n");
            return SLURM_ERROR;
      }
      
#ifdef HAVE_BG
      node_count = DIM_SIZE[X];
      table_x = DIM_SIZE[X] + DIM_SIZE[Z];
      table_y = (DIM_SIZE[Z] * DIM_SIZE[Y]) + DIM_SIZE[Y];
#else
      node_count = list_count(node_list);
      if(node_count < 50) {
            table_x = 1;
      } else if(node_count < 500) {
            table_x = 10;
      } else {
            table_x=20;
      }
      table_y = node_count/table_x;
      table_y++;
#endif

      gtk_table_resize(table, table_y, table_x);
      itr = list_iterator_create(node_list);
#ifdef HAVE_BG
      /* ok this is going to look much different than smap since we
       * get the nodes from the controller going up from the Z dim
       * instead of laying these out in a nice X fashion
       */
      for (x=0; x<DIM_SIZE[X]; x++) {
            y_offset = (DIM_SIZE[Z] * DIM_SIZE[Y]);
            for (y=0; y<DIM_SIZE[Y]; y++) {
                  coord_y = y_offset - y;
                  x_offset = DIM_SIZE[Z] - 1;
                  for (z=0; z<DIM_SIZE[Z]; z++){
                        coord_x = x + x_offset;
                        
                        grid_button = xmalloc(sizeof(grid_button_t));
                        grid_button->inx = i++;
                        grid_button->table = table;
                        grid_button->table_x = coord_x;
                        grid_button->table_y = coord_y;
                        grid_button->button = gtk_button_new();
                        grid_button->tip = gtk_tooltips_new();
                        if(!(sview_node_info_ptr = list_next(itr))) {
                              g_print("no node for this "
                                    "inx %d!!!!\n",
                                    grid_button->inx);
                              goto end_it;
                        }
                  
                        grid_button->node_name = xstrdup(
                              sview_node_info_ptr->node_ptr->name);
                        
                        gtk_tooltips_set_tip(grid_button->tip,
                                         grid_button->button,
                                         grid_button->node_name,
                                         "click for node stats");
                        gtk_widget_set_size_request(
                              grid_button->button, 10, 10);
                        g_signal_connect(G_OBJECT(grid_button->button),
                                     "button-press-event",
                                     G_CALLBACK(_open_node),
                                     grid_button);
                        list_append(button_list, grid_button);
                                                
                        gtk_table_attach(table, grid_button->button,
                                     coord_x, (coord_x+1),
                                     coord_y, (coord_y+1),
                                     GTK_SHRINK, GTK_SHRINK,
                                     1, 1);
                        
                        coord_y++;
                        x_offset--;
                  }
                  y_offset -= DIM_SIZE[Z];                  
            }
            gtk_table_set_row_spacing(table, coord_y-1, 5);
      }
#else
      for (x=0; x<node_count; x++) {
            grid_button = xmalloc(sizeof(grid_button_t));
            grid_button->inx = i++;
            grid_button->table = table;
            grid_button->table_x = coord_x;
            grid_button->table_y = coord_y;
            
            grid_button->button = gtk_button_new();
            grid_button->tip = gtk_tooltips_new();
            if(!(sview_node_info_ptr = list_next(itr))) {
                  g_print("no node for this "
                        "inx %d!!!!\n",
                        grid_button->inx);
                  goto end_it;
            }
            grid_button->node_name = xstrdup(
                  sview_node_info_ptr->node_ptr->name);
            gtk_tooltips_set_tip(grid_button->tip,
                             grid_button->button,
                             grid_button->node_name,
                             "click for node stats");
            gtk_widget_set_size_request(grid_button->button, 10, 10);
            g_signal_connect(G_OBJECT(grid_button->button), 
                         "button-press-event",
                         G_CALLBACK(_open_node),
                         grid_button);
            list_append(button_list, grid_button);
            
            gtk_table_attach(table, grid_button->button,
                         coord_x, (coord_x+1), coord_y, (coord_y+1),
                         GTK_SHRINK, GTK_SHRINK,
                         1, 1);
            
            coord_x++;
                  
            if(coord_x == table_x) {
                  coord_x = 0;
                  coord_y++;
                  if(!(coord_y%10)) {
                        gtk_table_set_row_spacing(table,
                                            coord_y-1, 5);
                  }
                  
            }
            
            if(coord_y == table_y)
                  break;
      
            if(coord_x && !(coord_x%10)) {
                  gtk_table_set_col_spacing(table,
                                      coord_x-1, 5);
            }
      }
#endif
      
end_it:
      list_iterator_destroy(itr);
      list_sort(button_list, (ListCmpF) _sort_button_inx);
      
      return error_code;
}

extern void sview_init_grid()
{
      node_info_msg_t *node_info_ptr = NULL;
      int error_code = SLURM_SUCCESS;
      node_info_t *node_ptr = NULL;
      int i = 0;
      uint16_t node_base_state;
      ListIterator itr = NULL;
      grid_button_t *grid_button = NULL;
      GdkColor color;

      if((error_code = get_new_info_node(&node_info_ptr, force_refresh))
         == SLURM_NO_CHANGE_IN_DATA) { 
            return;
      } else if (error_code != SLURM_SUCCESS) {
            return;
      }

      if(!grid_button_list) {
            g_print("you need to run get_system_stats() first\n");
            exit(0);
      }
      
      gdk_color_parse("white", &color);
      
      itr = list_iterator_create(grid_button_list);
      for(i=0; i<node_info_ptr->record_count; i++) {
            node_ptr = &node_info_ptr->node_array[i];
            list_iterator_reset(itr);
            while((grid_button = list_next(itr))) {
                  if (grid_button->inx != i)
                        continue;
                  node_base_state = node_ptr->node_state 
                        & NODE_STATE_BASE;
                  if (node_base_state == NODE_STATE_DOWN) {
                        _put_button_as_down(grid_button,
                                        NODE_STATE_DOWN);
                  } else if (node_ptr->node_state & NODE_STATE_DRAIN) {
                        _put_button_as_down(grid_button,
                                        NODE_STATE_DRAIN);
                  } else {
                        _put_button_as_up(grid_button);
                        grid_button->color = "white";
                        gtk_widget_modify_bg(grid_button->button, 
                                         GTK_STATE_NORMAL, &color);
                  }
                  grid_button->state = node_ptr->node_state;
                  break;
            }
      }
      list_iterator_destroy(itr);
}

extern void sview_reset_grid()
{
      grid_button_t *grid_button = NULL;
      uint16_t node_base_state;
      ListIterator itr = NULL;
      GdkColor color;
      
      if(!grid_button_list) {
            g_print("you need to run get_system_stats() first\n");
            exit(0);
      }
      gdk_color_parse("white", &color);
            
      itr = list_iterator_create(grid_button_list);
      while((grid_button = list_next(itr))) {
            node_base_state = grid_button->state & NODE_STATE_BASE;
            if ((node_base_state == NODE_STATE_DOWN)
                || (grid_button->state & NODE_STATE_DRAIN)) {
                  continue;
            }
            gtk_widget_modify_bg(grid_button->button, 
                             GTK_STATE_NORMAL, &color);
      }
      list_iterator_destroy(itr);
}

Generated by  Doxygen 1.6.0   Back to index