/home/fernape/Projects/lkmonitor/src/update.h File Reference

Go to the source code of this file.

Functions
void	update_cpu ()
	Update cpu pane.
void	update_cpu_mhz ()
	Update mhz variable in cpu pane.
void	update_mem ()
	Update mem pane.
void	update_devs ()
	Update devices pane.
void	update_settings ()
	Update settings pane.
void	update_misc ()
	Update misc pane.
void	update_process ()
	Update the process panel.
void	update_cmd_ver ()
	Update cmdline and version info.
void	update_channels ()
	Update communication channels panel.
void	update_net_info ()
	Update networking information.
void	update_fs_info ()
	Update filesystems information.
void	update_modules_info ()
	Update modules information.

---

Function Documentation

void update_channels

(

)

Update communication channels panel.

Updates communication channels tab

Definition at line 640 of file update.c.

References cn_info, channels_info::dma, get_channels_info(), channels_info::iomem, channels_info::ioports, lookup_widget(), and window1.

Referenced by main(), and on_btn_comm_reload_clicked().

{

/* IMPORTANT:
                We should not lock with gdk_threads_enter because this function is 
                called from a callback and callbacks are already running inside a gdk
                lock.
                In addition, this function is called from main thread before the collector
                thread is created, so we don't need to prevent the access from the other
                thread.
*/
        
        GtkTextView *gtextv;
        GtkTextBuffer *gtbuffer;

        /* Getting information */
   if(get_channels_info(&cn_info)==-1){
                /* Values after calling get_channels info are safe
                        We don't need to do anything here.
                */
        }
   

        gtextv=GTK_TEXT_VIEW(lookup_widget(window1, "gtextv_ioports"));
        gtbuffer=gtk_text_view_get_buffer(gtextv);
        gtk_text_buffer_set_text(gtbuffer,cn_info.ioports->str,cn_info.ioports->len);
        
        gtextv=GTK_TEXT_VIEW(lookup_widget(window1, "gtextv_iomem"));
        gtbuffer=gtk_text_view_get_buffer(gtextv);
        gtk_text_buffer_set_text(gtbuffer,cn_info.iomem->str,cn_info.iomem->len);
        
        gtextv=GTK_TEXT_VIEW(lookup_widget(window1, "gtextv_dma"));
        gtbuffer=gtk_text_view_get_buffer(gtextv);
        gtk_text_buffer_set_text(gtbuffer,cn_info.dma->str,cn_info.dma->len);
   
}

void update_cmd_ver

(

)

Update cmdline and version info.

Updates command line and version information in the window

Definition at line 614 of file update.c.

References cmd_ver::cmd, cmdversion, get_cmd_ver_info(), lookup_widget(), cmd_ver::version, and window1.

Referenced by main().

{
  GtkLabel *lbl;

        /* Get the information */
  if(get_cmd_ver_info(&cmdversion)==-1){
                /* We don't need to do anything. The cmdversion structure
                        has the default values.
                */
  }

  gdk_threads_enter();

  lbl=GTK_LABEL(lookup_widget(window1,"lbl_cmd"));
  gtk_label_set_text(lbl,cmdversion.cmd->str);

  lbl=GTK_LABEL(lookup_widget(window1,"lbl_version"));
  gtk_label_set_text(lbl,cmdversion.version->str);

  gdk_threads_leave();

}

void update_cpu

(

)

Update cpu pane.

Update gtk widgets for cpu panel This function updates labels to show recent values. Before, it calls to get_cpu_info to collect data

Definition at line 166 of file update.c.

References cpu_info::bogomips, cpu_info::cache, cpu, cpu_info::cpu_family, cpu_info::cpuid_level, cpu_info::flags, cpu_info::fpu, cpu_info::fpu_exception, get_cpu_info(), lookup_widget(), cpu_info::Mhz, cpu_info::model, cpu_info::model_name, cpu_info::processor, cpu_info::stepping, cpu_info::vendor_id, window1, and cpu_info::wp.

Referenced by main().

{

  get_cpu_info (&cpu);

  GtkLabel *widget;

  /*Not updated so, we don't need thread locking*/
        
  widget = GTK_LABEL( lookup_widget (window1, "lbl_processor"));
  gtk_label_set_text (widget, (gchar *) cpu.processor);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_vendor"));
  gtk_label_set_text (widget, (gchar *) cpu.vendor_id);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_family"));
  gtk_label_set_text (widget, (gchar *) cpu.cpu_family);


  widget = GTK_LABEL( lookup_widget (window1, "lbl_model"));
  gtk_label_set_text (widget, (gchar *) cpu.model);

  widget = GTK_LABEL(lookup_widget (window1, "lbl_model_name"));
  gtk_label_set_text (widget, (gchar *) cpu.model_name);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_stepping"));
  gtk_label_set_text (widget, (gchar *) cpu.stepping);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_Mhz"));
  gtk_label_set_text (widget, (gchar *) cpu.Mhz);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_cache"));
  gtk_label_set_text (widget, (gchar *) cpu.cache);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_fpu"));
  gtk_label_set_text (widget, (gchar *) cpu.fpu);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_fpu_exception"));
  gtk_label_set_text (widget, (gchar *) cpu.fpu_exception);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_cpu_id_level"));
  gtk_label_set_text (widget, (gchar *) cpu.cpuid_level);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_wp"));
  gtk_label_set_text (widget, (gchar *) cpu.wp);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_bogomips"));
  gtk_label_set_text (widget, (gchar *) cpu.bogomips);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_flags"));
  gtk_label_set_text (widget, (gchar *) cpu.flags);

 
}

void update_cpu_mhz

(

void

)

Update mhz variable in cpu pane.

Update MHz label in cpu pane This is the only dynamic feature in cpu pane.

Definition at line 224 of file update.c.

References get_mhz_info(), lookup_widget(), and window1.

Referenced by refresh().

{
        GtkLabel *mhz_label;
        char str[10];
        
        get_mhz_info(str);
        
        gdk_threads_enter();
        
        mhz_label=GTK_LABEL(lookup_widget(window1,"lbl_Mhz"));
        gtk_label_set_text(mhz_label,str);
        
        gdk_threads_leave();
}

void update_devs

(

)

Update devices pane.

Update treeviews for devices pane This is called from a callback

Definition at line 242 of file update.c.

References dev_info::blocks, dev_info::characters, devs, get_devs_info(), lkmonitor_fill_tv(), lookup_widget(), TV_DEVS, and window1.

Referenced by main(), and on_btn_dev_load_clicked().

{
        if(get_devs_info(&devs)==-1){
                /*File doesn't exist. Don't do anything*/
                return;
        }
        
        GtkListStore *model;
        GtkTreeView *gtv;
        GtkTreeIter iter;

        /* IMPORTANT:
                We should not lock with gdk_threads_enter because this function is 
                called from a callback and callbacks are already running inside a gdk
                lock.
                In addition, this function is called from main thread before the collector
                thread is created, so we don't need to prevent the access from the other
                thread.
        */

        /* We want the model of the GtkTreeView for char devices */
        gtv=GTK_TREE_VIEW(lookup_widget(window1,"gtv_char"));
        model=GTK_LIST_STORE(gtk_tree_view_get_model(gtv));

        gtk_tree_view_set_model(gtv,NULL);
        gtk_list_store_clear(model);
        lkmonitor_fill_tv(model,gtv,iter,devs.characters->str,TV_DEVS);
        gtk_tree_view_set_model(gtv,GTK_TREE_MODEL(model));

        /* We want the model of the GtkTreeView for block devices */
        gtv=GTK_TREE_VIEW(lookup_widget(window1,"gtv_block"));
        model=GTK_LIST_STORE(gtk_tree_view_get_model(gtv));
        gtk_tree_view_set_model(gtv,NULL);
        gtk_list_store_clear(model);
        lkmonitor_fill_tv(model,gtv,iter,devs.blocks->str,TV_DEVS);
        gtk_tree_view_set_model(gtv,GTK_TREE_MODEL(model));

}

void update_fs_info

(

)

Update filesystems information.

Updates filesystems tab

Definition at line 759 of file update.c.

References fs_info::devs, fsinfo, get_fs_info(), lookup_widget(), fs_info::nodevs, and window1.

Referenced by refresh().

{

  GtkTextBuffer *gtbuffer;
  GtkTextView *gtextv;
  int ret;

  /* Get information */
  ret = get_fs_info(&fsinfo);

  if(ret == -1){
        /* Return values in fsinfo are safe. Don't need do anything here*/
  }

  gdk_threads_enter();

  /* Show in the window*/

  gtextv=GTK_TEXT_VIEW(lookup_widget(window1,"gtextv_fs"));
  gtbuffer=gtk_text_view_get_buffer(gtextv);
  gtk_text_buffer_set_text(gtbuffer,fsinfo.devs->str,fsinfo.devs->len);
  

  gtextv=GTK_TEXT_VIEW(lookup_widget(window1,"gtextv_pfs"));
  gtbuffer=gtk_text_view_get_buffer(gtextv);
  gtk_text_buffer_set_text(gtbuffer,fsinfo.nodevs->str,fsinfo.nodevs->len);

  gdk_threads_leave();

  
}

void update_mem

(

)

Update mem pane.

Update gtk widgets for memory panel This function updates labels, progress bar and other widgets to show the most recent values. Before, it calls to get_mem_info to collect data

Definition at line 66 of file update.c.

References mem_info::active, mem_info::buffers, mem_info::cached, mem_info::dirty, mem_info::free, get_mem_info(), mem_info::high_free, mem_info::high_total, mem_info::hugepages_free, mem_info::hugepages_size, mem_info::hugepages_total, mem_info::inactive, lookup_widget(), mem_info::low_free, mem_info::low_total, mem, mem_info::swap_cached, mem_info::swap_free, mem_info::swap_total, mem_info::total, and window1.

Referenced by refresh().

{

  GtkLabel *widget;
  GtkProgressBar *progreso;
  gfloat total, free;

  get_mem_info (&mem);
        
  //Get Gtk thread lock
  gdk_threads_enter();


  widget = GTK_LABEL(lookup_widget (window1, "lbl_total"));
  gtk_label_set_text (widget, (gchar *) mem.total);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_free"));
  gtk_label_set_text (widget, (gchar *) mem.free);

  widget = GTK_LABEL(lookup_widget (window1, "lbl_buffers"));
  gtk_label_set_text (widget, (gchar *) mem.buffers);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_cached"));
  gtk_label_set_text (widget, (gchar *) mem.cached);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_swap_cached"));
  gtk_label_set_text (widget, (gchar *) mem.swap_cached);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_active"));
  gtk_label_set_text (widget, (gchar *) mem.active);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_inactive"));
  gtk_label_set_text (widget, (gchar *) mem.inactive);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_dirty"));
  gtk_label_set_text (widget, (gchar *) mem.dirty);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_hp_total"));
  gtk_label_set_text (widget, (gchar *) mem.hugepages_total);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_hp_free"));
  gtk_label_set_text (widget, (gchar *) mem.hugepages_free);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_hp_size"));
  gtk_label_set_text (widget, (gchar *) mem.hugepages_size);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_high_total"));
  gtk_label_set_text (widget, (gchar *) mem.high_total);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_high_free"));
  gtk_label_set_text (widget, (gchar *) mem.high_free);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_low_total"));
  gtk_label_set_text (widget, (gchar *) mem.low_total);


  widget = GTK_LABEL( lookup_widget (window1, "lbl_low_free"));
  gtk_label_set_text (widget, (gchar *) mem.low_free);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_swap_total"));
  gtk_label_set_text (widget, (gchar *) mem.swap_total);

  widget = GTK_LABEL( lookup_widget (window1, "lbl_swap_free"));
  gtk_label_set_text (widget, (gchar *) mem.swap_free);

  /*Compute percentage of memory use*/
  total = atoi (strtok (mem.total, " "));
  free = atoi (strtok (mem.free, " "));

  g_assert(total!=0);
  
  progreso = GTK_PROGRESS_BAR(lookup_widget (window1, "pb_mem"));
  gtk_progress_bar_set_fraction (progreso, 
                                                        (gfloat) CLAMP(((total - free) / total),0,1));


  /*Compute percentage of swap use. Reuse variables.*/


  total = atoi (strtok (mem.swap_total, " "));
  free = atoi (strtok (mem.swap_free, " "));
  
  progreso = GTK_PROGRESS_BAR (lookup_widget (window1, "pb_swap"));
  
  if(total!=0){
    gtk_progress_bar_set_fraction (progreso, 
                                                        (gfloat) CLAMP(((total - free) / total),0,1));
          }
  else
    gtk_progress_bar_set_text(progreso, (gchar *)_("Not present"));
  
  gdk_threads_leave();
}                               

void update_misc

(

)

Update misc pane.

Update misc panel Updates labels and spinbuttons

Definition at line 379 of file update.c.

References acpi, acpi_info::battery, battery_info::cap, battery_info::cap_low, battery_info::cap_warning, stats_info::cpu, stats_info::ctxt, get_acpi_info(), get_stats_info(), battery_info::last_cap, lookup_widget(), battery_info::rem, stats, acpi_info::temp, acpi_info::temp_critical, battery_info::type, and window1.

Referenced by refresh().

{
        GtkLabel *lbl;
        GtkProgressBar *pb;
        gfloat total,free;
        static float old_total,old_use;
        float use;
        gchar percent[4];
        gchar user[10];
        gchar nice[10];
        gchar system[10];
        gchar idle[10];
        gchar iowait[10];
        gchar irq[10];
        gchar softirq[10];
        int ret_stats, ret_acpi;        


        ret_acpi = get_acpi_info(&acpi);
        
        ret_stats = get_stats_info(&stats);
        sscanf(stats.cpu->str,"%s %s %s %s %s %s %s",user,nice,system,idle,iowait,\
                                                                                                        irq,softirq);
        gdk_threads_enter();
        
  if(ret_stats!=-1){
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_user"));
        gtk_label_set_text(lbl,user);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_nice"));
        gtk_label_set_text(lbl,nice);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_system"));
        gtk_label_set_text(lbl,system);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_idle"));
        gtk_label_set_text(lbl,idle);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_iowait"));
        gtk_label_set_text(lbl,iowait);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_irq"));
        gtk_label_set_text(lbl,irq);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_softirq"));
        gtk_label_set_text(lbl,softirq);
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_context"));
        gtk_label_set_text(lbl,stats.ctxt->str);
        
        total=atof(user)+atof(nice)+atof(system)+atof(idle)+atof(iowait)+
                        atof(irq)+atof(softirq);
                        
        free=atof(idle)+atof(iowait)+atof(irq)+atof(softirq);
        use=total-free;
                        
        pb=GTK_PROGRESS_BAR(lookup_widget(window1,"pb_cpu"));
        gtk_progress_bar_set_fraction(pb,CLAMP((use-old_use)/(total-old_total),0,1));
        sprintf(percent,"%.0f%s",CLAMP((use-old_use),0,100),"%");
        gtk_progress_bar_set_text(pb,percent);
        
        old_use=use;
        old_total=total;

        }

        /*Update ACPI*/

  if(ret_acpi != -1){

        lbl=GTK_LABEL(lookup_widget(window1,"lbl_cap"));
        gtk_label_set_text(lbl,acpi.battery.cap->str);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_last_cap"));
        gtk_label_set_text(lbl,acpi.battery.last_cap->str);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_cap_warning"));
        gtk_label_set_text(lbl,acpi.battery.cap_warning->str);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_cap_low"));
        gtk_label_set_text(lbl,acpi.battery.cap_low->str);
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_batt_type"));
        gtk_label_set_text(lbl,acpi.battery.type->str);
        
        if(strcmp(acpi.temp->str,"")!=0){
                total=atof(acpi.temp_critical->str);
                free=atof(acpi.temp->str);
        
                pb=GTK_PROGRESS_BAR(lookup_widget(window1,"pb_temp"));
                gtk_progress_bar_set_fraction(pb,free/total);
                gtk_progress_bar_set_text(pb,acpi.temp->str);
        }else{
                pb=GTK_PROGRESS_BAR(lookup_widget(window1,"pb_temp"));
                gtk_progress_bar_set_text(pb,_("Unknown"));
        }

        if(strcmp(acpi.battery.rem->str,"")!=0){
                total=atof(acpi.battery.cap->str);
                free=atof(acpi.battery.rem->str);
        
                pb=GTK_PROGRESS_BAR(lookup_widget(window1,"pb_batt"));
                gtk_progress_bar_set_fraction(pb,free/total);
                gtk_progress_bar_set_text(pb,acpi.battery.rem->str);
        }else{
                pb=GTK_PROGRESS_BAR(lookup_widget(window1,"pb_batt"));
                gtk_progress_bar_set_text(pb,_("Unknown"));
        }
  
 }  
        
  gdk_threads_leave();
}

void update_modules_info

(

)

Update modules information.

Updates modules tab

Definition at line 795 of file update.c.

References modules_info::contents, get_mod_info(), lkmonitor_fill_tv(), lookup_widget(), modinfo, TV_MODS, and window1.

Referenced by main(), and on_modules_refresh_clicked().

{

        GtkListStore *model;
        GtkTreeView *gtv;
        GtkTreeIter iter;
        int ret;

        /* Get information */
        ret = get_mod_info(&modinfo);

        /* IMPORTANT:
                We should not lock with gdk_threads_enter because this function is 
                called from a callback and callbacks are already running inside a gdk
                lock.
                In addition, this function is called from main thread before the collector
                thread is created, so we don't need to prevent the access from the other
                thread.
        */

  if(ret != -1){
        /* We want the model of the GtkTreeView */
        gtv=GTK_TREE_VIEW(lookup_widget(window1,"gtv_modules"));
        model=GTK_LIST_STORE(gtk_tree_view_get_model(gtv));

        gtk_tree_view_set_model(gtv,NULL);
        gtk_list_store_clear(model);
        lkmonitor_fill_tv(model,gtv,iter,modinfo.contents->str,TV_MODS);
        gtk_tree_view_set_model(gtv,GTK_TREE_MODEL(model));
  }

}

void update_net_info

(

)

Update networking information.

Updates net tab

Definition at line 679 of file update.c.

References net_dev_info::bytes, net_dev_info::compressed, net_dev_info::drop, net_dev_info::errs, net_dev_info::fifo, get_net_info(), lkmonitor_itoa(), lookup_widget(), netinfo, net_dev_info::packets, net_dev_info::r_frame, net_dev_info::r_multicast, net_dev_info::t_carrier, net_dev_info::t_colls, and window1.

Referenced by main(), and refresh().

{
  GtkComboBox *gcb_netdevs;
  GtkLabel *lbl;
  int ret;
 
        /* Get device list */
  gdk_threads_enter();
  gcb_netdevs=GTK_COMBO_BOX(lookup_widget(window1,"cb_net_devs"));
  gdk_threads_leave();

if(GTK_WIDGET_IS_SENSITIVE(gcb_netdevs)){
  /* Get info for the active device */ 
  ret = get_net_info(&netinfo,gtk_combo_box_get_active(gcb_netdevs));
  
 if(ret != -1){
  gdk_threads_enter();

  /* Show in the window... */  
  
  /* Bytes */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_bytes"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.bytes[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_bytes"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.bytes[1]));

  /* Packets */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_packets"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.packets[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_packets"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.packets[1]));

  /* Errors */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_errors"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.errs[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_errors"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.errs[1]));

  /* Drop */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_drop"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.drop[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_drop"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.drop[1]));
  
  /* Fifo */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_fifo"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.fifo[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_fifo"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.fifo[1]));

  /* Compressed */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_compressed"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.compressed[0]));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_compressed"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.compressed[1]));


  /* Receiving specific data */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_frame"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.r_frame));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_r_multicast"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.r_multicast));

  /* Transmiting specific data */
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_colls"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.t_colls));
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_t_carrier"));
  gtk_label_set_text(lbl,(gchar *)lkmonitor_itoa(netinfo.t_carrier));

  gdk_threads_leave();

 }

}

}

void update_process

(

)

Update the process panel.

Update the process tab

Definition at line 580 of file update.c.

References cmdversion, get_loadavg_info(), cmd_ver::loadavg, lookup_widget(), lnode::pid, and window1.

Referenced by refresh().

{
  GtkLabel *lbl;
  GString *text;
  float one,five,fifteen;
  int pid,ret;
  char executing[15];   /*big enough to read that value*/
  

        /* First the process list */
  update_process_list();

  /*Now we want to update the load average information*/
  ret = get_loadavg_info(&cmdversion);  

  sscanf(cmdversion.loadavg->str,"%f %f %f %s %d",&one,&five,&fifteen, executing,&pid);
  text=g_string_new("");
  if(ret != -1)
        g_string_printf(text,"%.2f %.2f %.2f",one,five,fifteen);

  gdk_threads_enter();
    
  lbl=GTK_LABEL(lookup_widget(window1,"lbl_load"));
  gtk_label_set_text(lbl,text->str);

  lbl=GTK_LABEL(lookup_widget(window1,"lbl_entities"));
  gtk_label_set_text(lbl,executing);

  gdk_threads_leave();

}

void update_settings

(

)

Update settings pane.

Update gtk widgets for settings panel Called from a callback

Definition at line 284 of file update.c.

References settings_info::domain, settings_info::fdasig, settings_info::fdfreed, settings_info::fdmax, get_settings_info(), settings_info::host, settings_info::inasig, settings_info::inmax, lookup_widget(), settings_info::max_opcall, settings_info::max_seminset, settings_info::max_semsets, settings_info::max_semsys, settings_info::page_max, settings_info::posix_mpq, settings_info::posix_mq, settings_info::posix_ms, settings_info::seg_max, settings_info::seg_size, settings, settings_info::threads, and window1.

Referenced by main(), on_btn_load_clicked(), and on_btn_write_clicked().

{
        GtkSpinButton *spb;
        GtkLabel *lbl;
        GtkEntry *ent;
        gchar str[10]; /* For numeric conversion. */
        
        if(get_settings_info(&settings)==1){
                /* I leave this section just in case. Should the code in get_settings_info
                        doesn't find the date, default values are set. We can safely update
                        the gtk widgets.
                */
        }

        /* IMPORTANT:
                We should not lock with gdk_threads_enter because this function is 
                called from a callback and callbacks are already running inside a gdk
                lock.
                In addition, this function is called from main thread before the collector
                thread is created, so we don't need to prevent the access from the other
                thread.
        */
        
        /* Identification */
        ent=GTK_ENTRY(lookup_widget(window1,"ent_hostname"));
        gtk_entry_set_text(ent,settings.host->str);
        
        ent=GTK_ENTRY(lookup_widget(window1,"ent_domainname"));
        gtk_entry_set_text(ent,settings.domain->str);
        
        
        /* threads */
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_maxthreads"));
        gtk_spin_button_set_value(spb,(gdouble)settings.threads);
        
        /* files */
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_fdmax"));
        gtk_spin_button_set_value(spb,(gdouble)settings.fdmax);
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_inmax"));
        sprintf(str,"%d",settings.inmax);
        gtk_label_set_text(lbl,str);
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_fda"));
        sprintf(str,"%d",settings.fdasig);
        gtk_label_set_text(lbl,str);
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_ufd"));
        sprintf(str,"%d",settings.fdfreed);
        gtk_label_set_text(lbl,str);
        
        lbl=GTK_LABEL(lookup_widget(window1,"lbl_ina"));
        sprintf(str,"%d",settings.inasig);
        gtk_label_set_text(lbl,str);
        
        /* RT POSIX Signals */
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_mq"));
        gtk_spin_button_set_value(spb,(gdouble)settings.posix_mq);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_max_mpq"));
        gtk_spin_button_set_value(spb,(gdouble)settings.posix_mpq);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_max_ms"));
        gtk_spin_button_set_value(spb,(gdouble)settings.posix_ms);
        
        /* Shared Memory */
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_max_pages"));
        gtk_spin_button_set_value(spb,(gdouble)settings.page_max);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_max_segs"));
        gtk_spin_button_set_value(spb,(gdouble)settings.seg_max);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_seg_size"));
        gtk_spin_button_set_value(spb,(gdouble)settings.seg_size);
        
        /* Semaphores */
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_sem_per_id"));
        gtk_spin_button_set_value(spb,(gdouble)settings.max_seminset);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_sem_val"));
        gtk_spin_button_set_value(spb,(gdouble)settings.max_semsys);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_ops"));
        gtk_spin_button_set_value(spb,(gdouble)settings.max_opcall);
        
        spb=GTK_SPIN_BUTTON(lookup_widget(window1,"spb_sem_id"));
        gtk_spin_button_set_value(spb,(gdouble)settings.max_semsets);
        
        
}

---