Logo Search packages:      
Sourcecode: hardinfo version File versions  Download package

hardinfo.c

/*
 * Hardware Information, version 0.3.2
 * Copyright (C) 2003 Leandro Pereira <leandro@linuxmag.com.br>
 *
 * May be modified and/or distributed under the terms of GNU GPL version 2.
 *
 */

#include "hardinfo.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

#include "pixmaps/pci.xpm"
#include "pixmaps/usb.xpm"
#include "pixmaps/hdd.xpm"
#include "pixmaps/gen_connector.xpm"
#include "pixmaps/scsi.xpm"
#include "pixmaps/processor.xpm"

#include "computer.h"
#include "status.h"
#include "stock.h"

GenericDevice *generic_devices = NULL;

void hi_enable_details_button(GtkCTree * tree, GList * node,
                   gint column, gpointer user_data);
void hi_enable_details_button_real(MainWindow *mainwindow, GenericDevice *dev);
void hi_disable_details_button(GtkCTree * tree, GList * node,
                   gint column, gpointer user_data);
void hi_scan_all(MainWindow * mainwindow);

void
main_window_refresh(GtkWidget * widget, gpointer data)
{
      MainWindow *mainwindow = (MainWindow *) data;

      if (!mainwindow)
            return;

      hi_disable_details_button(NULL, NULL, 0, mainwindow);

      memory_update(mainwindow);
      uptime_update(mainwindow);
      net_update(mainwindow);

      hi_scan_all(mainwindow);
}

static void
about_window_create(void)
{
      GtkAbout *about;
      const gchar *sysinfo = HOSTNAME " (" PLATFORM KERNEL ")";
      const gchar *authors[] = {
            ">Written by:",
            "Leandro A. F. Pereira (leandro@linuxmag.com.br)",
            ">Disclaimer:",
            "This is free software; you can modify and/or distribute it",
            "under the terms of GNU GPL version 2. See http://www.fsf.org/",
            "for more information.",
            ">Compiled on:",
            sysinfo,
            NULL
      };

      about = gtk_about_new("HardInfo", VERSION,
                        _("System information tool for GNU/Linux.\n"),
                        authors, IMG_PREFIX "logo.png");

}

MainWindow *
main_window_create(void)
{
      GtkWidget *window, *mbox, *vbox, *ctree, *scroll;
      GtkWidget *notebook, *label, *hbox, *btn, *hbbox;
      MainWindow *mainwindow;

      mainwindow = g_new0(MainWindow, 1);

      mainwindow->det_window = detail_window_new();

      window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
      gtk_container_set_border_width(GTK_CONTAINER(window), 4);
      gtk_window_set_title(GTK_WINDOW(window), _("System Information"));

      g_signal_connect(G_OBJECT(window), "delete-event", gtk_main_quit, NULL);
      gtk_window_set_icon_from_file(GTK_WINDOW(window), IMG_PREFIX "logo.png", NULL);

      mbox = gtk_vbox_new(FALSE, 5);
      gtk_widget_show(mbox);
      gtk_container_add(GTK_CONTAINER(window), mbox);

      notebook = gtk_notebook_new();
      gtk_box_pack_start(GTK_BOX(mbox), notebook, TRUE, TRUE, 0);

      /*
       * Computer tab
       */
      vbox = gtk_vbox_new(FALSE, 5);
      gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
      gtk_widget_show(vbox);
      gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
                         gtk_label_new(_("Computer")));

      label = gtk_label_new(_("<b><big>Operating System</big></b>"));
      gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
      gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
      gtk_widget_show(label);
      gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
      gtk_box_pack_start(GTK_BOX(vbox), os_get_widget(mainwindow),
                     FALSE, FALSE, 0);

      label = gtk_label_new(_("<b><big>Processor</big></b>"));
      gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
      gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
      gtk_widget_show(label);
      gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
      gtk_box_pack_start(GTK_BOX(vbox), processor_get_widget(), FALSE,
                     FALSE, 0);

      label = gtk_label_new(_("<b><big>Memory Usage</big></b>"));
      gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
      gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
      gtk_widget_show(label);
      gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
      gtk_box_pack_start(GTK_BOX(vbox), memory_get_widget(mainwindow),
                     FALSE, FALSE, 0);

      /*
       * Devices tab
       */
      vbox = gtk_vbox_new(FALSE, 5);
      gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
      gtk_widget_show(vbox);
      gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
                         gtk_label_new(_("Details")));

      hbbox = gtk_hbutton_box_new();
      gtk_container_set_border_width(GTK_CONTAINER(hbbox), 4);
      gtk_widget_show(hbbox);
      gtk_box_pack_end(GTK_BOX(vbox), hbbox, FALSE, FALSE, 0);
      gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 6);
      gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END);

      btn = gtk_button_new_from_stock(HI_DETAILS);
      g_signal_connect(G_OBJECT(btn), "clicked",
                   (GCallback) detail_window_show, mainwindow);
      gtk_widget_show(btn);
      gtk_box_pack_end(GTK_BOX(hbbox), btn, FALSE, FALSE, 0);
      mainwindow->details_button = btn;

      scroll = gtk_scrolled_window_new(NULL, NULL);
      gtk_box_pack_start(GTK_BOX(vbox), scroll, TRUE, TRUE, 0);
      gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scroll),
                               GTK_POLICY_AUTOMATIC,
                               GTK_POLICY_AUTOMATIC);

      ctree = gtk_ctree_new(2, 0);
      gtk_container_add(GTK_CONTAINER(scroll), ctree);
      gtk_widget_set_usize(GTK_WIDGET(ctree), 400, 300);
      gtk_ctree_set_expander_style(GTK_CTREE(ctree),
                             GTK_CTREE_EXPANDER_TRIANGLE);
      gtk_ctree_set_line_style(GTK_CTREE(ctree), GTK_CTREE_LINES_NONE);
      gtk_clist_set_column_width(GTK_CLIST(ctree), 0, 32);
      gtk_clist_set_column_width(GTK_CLIST(ctree), 1, 32);
      gtk_clist_set_row_height(GTK_CLIST(ctree), 18);
      g_signal_connect(G_OBJECT(ctree), "tree-select-row",
                   (GCallback) hi_enable_details_button, mainwindow);
      g_signal_connect(G_OBJECT(ctree), "tree-unselect-row",
                   (GCallback) hi_disable_details_button, mainwindow);
                   
      /*
       * Environment tab
       */
      vbox = gtk_vbox_new(FALSE, 5);
      gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
      gtk_widget_show(vbox);
      gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
                         gtk_label_new(_("Environment")));

      label = gtk_label_new(_("<b><big>X-Window System</big></b>"));
      gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
      gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
      gtk_widget_show(label);
      gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
//    gtk_box_pack_start(GTK_BOX(vbox), x11_get_widget(mainwindow),
//                   FALSE, FALSE, 0);

      /*
       * Network tab
       */
      vbox = gtk_vbox_new(FALSE, 5);
      gtk_container_set_border_width(GTK_CONTAINER(vbox), 4);
      gtk_widget_show(vbox);
      gtk_notebook_append_page(GTK_NOTEBOOK(notebook), vbox,
                         gtk_label_new(_("Network")));

      label = gtk_label_new(_("<b><big>Interfaces</big></b>"));
      gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
      gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
      gtk_widget_show(label);
      gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
      gtk_box_pack_start(GTK_BOX(vbox), net_get_widget(mainwindow),
                     TRUE, TRUE, 0);

      /*
       * Buttons
       */
      hbox = gtk_hbox_new(FALSE, 5);
      gtk_widget_show(hbox);
      gtk_box_pack_start(GTK_BOX(mbox), hbox, FALSE, FALSE, 0);
      
      hbbox = gtk_hbutton_box_new();
      gtk_container_set_border_width(GTK_CONTAINER(hbbox), 4);
      gtk_widget_show(hbbox);
      gtk_box_pack_start(GTK_BOX(hbox), hbbox, FALSE, FALSE, 0);
      gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 6);
      gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_START);

      btn = gtk_button_new_from_stock(HI_ABOUT);
      g_signal_connect(G_OBJECT(btn), "clicked",
                   (GCallback) about_window_create, NULL);
      gtk_widget_show(btn);
      gtk_box_pack_start(GTK_BOX(hbbox), btn, FALSE, FALSE, 0);

      hbbox = gtk_hbutton_box_new();
      gtk_container_set_border_width(GTK_CONTAINER(hbbox), 4);
      gtk_widget_show(hbbox);
      gtk_box_pack_end(GTK_BOX(hbox), hbbox, FALSE, FALSE, 0);
      gtk_button_box_set_spacing(GTK_BUTTON_BOX(hbbox), 6);
      gtk_button_box_set_layout(GTK_BUTTON_BOX(hbbox), GTK_BUTTONBOX_END);

      btn = gtk_button_new_from_stock(GTK_STOCK_REFRESH);
      g_signal_connect(G_OBJECT(btn), "clicked",
                   (GCallback) main_window_refresh, mainwindow);
      gtk_widget_show(btn);
      gtk_box_pack_start(GTK_BOX(hbbox), btn, FALSE, FALSE, 0);

      btn = gtk_button_new_from_stock(GTK_STOCK_CLOSE);
      g_signal_connect(G_OBJECT(btn), "clicked", gtk_main_quit, NULL);
      gtk_widget_show(btn);
      gtk_box_pack_start(GTK_BOX(hbbox), btn, FALSE, FALSE, 0);

      gtk_widget_show_all(window);

      mainwindow->window = window;
      mainwindow->ctree = ctree;

      return mainwindow;
}

static GdkColor
gdk_color_from_rgb(gint r, gint g, gint b)
{
      GdkColormap *cmap = NULL;
      GdkColor color;

      if (!cmap) {
            cmap = gdk_colormap_get_system();
            gdk_colormap_ref(cmap);
      }

      color.red = r * 255;
      color.green = g * 255;
      color.blue = b * 255;

      gdk_color_alloc(cmap, &color);
      gdk_colormap_unref(cmap);

      return color;
}

GtkCTreeNode *
tree_group_new(MainWindow * mainwindow, const gchar * name, DeviceType type)
{
      GtkCTreeNode *node;
      const gchar *text[] = { NULL, name, NULL };
      GdkPixmap *pixmap = NULL;
      GdkBitmap *mask = NULL;
      GdkColor color;
      GdkColormap *colormap = NULL;

      if (!name)
            return NULL;
      if (type == NONE)
            return NULL;
      if (!mainwindow)
            return NULL;

      colormap = gtk_widget_get_colormap(mainwindow->window);

      switch (type) {
      case PARPORT:
      case SERIAL:
            pixmap = gdk_pixmap_colormap_create_from_xpm_d
                (NULL, colormap, &mask, NULL, gen_connector_xpm);
            break;
      case V4L:
      case PCI:
      case ISAPnP:
            pixmap = gdk_pixmap_colormap_create_from_xpm_d
                (NULL, colormap, &mask, NULL, pci_xpm);
            break;
      case SCSI:
            pixmap = gdk_pixmap_colormap_create_from_xpm_d
                (NULL, colormap, &mask, NULL, scsi_xpm);
            break;
      case IDE:
            pixmap = gdk_pixmap_colormap_create_from_xpm_d
                (NULL, colormap, &mask, NULL, hdd_xpm);
            break;
      case USB:
            pixmap = gdk_pixmap_colormap_create_from_xpm_d
                (NULL, colormap, &mask, NULL, usb_xpm);
            break;
      case MODULE:
      case PROCESSOR:
            pixmap = gdk_pixmap_colormap_create_from_xpm_d
                (NULL, colormap, &mask, NULL, processor_xpm);
            break;
      default:
            mask = pixmap = NULL;
            break;
      }

      node = gtk_ctree_insert_node(GTK_CTREE(mainwindow->ctree),
                             NULL, NULL, text, 0, pixmap, mask, pixmap,
                             mask, FALSE, TRUE);

      color = gdk_color_from_rgb(0xcc, 0xcc, 0xcc);
      gtk_ctree_node_set_background(GTK_CTREE(mainwindow->ctree),
                              node, &color);

      gdk_pixmap_unref(pixmap);
      gdk_bitmap_unref(mask);

      return node;
}

void
tree_insert_item(MainWindow * mainwindow, GtkCTreeNode * group, gchar * name,
             gpointer data)
{
      GtkCTreeNode *node;
      gchar *text[] = { NULL, name, NULL };

      if (!mainwindow)
            return;
      if (!name)
            return;
      if (!group)
            return;

      node = gtk_ctree_insert_node(GTK_CTREE(mainwindow->ctree),
                             group, NULL,
                             text, 0,
                             NULL, NULL, NULL, NULL, FALSE, TRUE);
      gtk_ctree_node_set_row_data(GTK_CTREE(mainwindow->ctree), node, data);
}

void
hi_insert_generic(gpointer device, DeviceType type)
{
      GenericDevice *generic;

      generic = g_new0(GenericDevice, 1);

      generic->next = generic_devices;
      generic_devices = generic;

      generic_devices->device = device;
      generic_devices->type = type;
}

void
hi_disable_details_button(GtkCTree * tree, GList * node,
                gint column, gpointer user_data)
{
      MainWindow *mainwindow = (MainWindow *) user_data;

      gtk_widget_set_sensitive(GTK_WIDGET(mainwindow->details_button), FALSE);
}

void hi_enable_details_button(GtkCTree * tree, GList * node,
                gint column, gpointer user_data)
{
      MainWindow *mainwindow = (MainWindow *) user_data;

      gtk_widget_set_sensitive(GTK_WIDGET(mainwindow->details_button), TRUE);
}

void hi_show_device_info_real(MainWindow *mainwindow, GenericDevice *dev)
{
      if (!dev)
            return;

#define dev_info(type,name,func) \
      { \
            type *name; \
            name = (type *)dev->device; \
            func(mainwindow, name); \
      } \
      break;

      switch (dev->type) {
      case MODULE:
            dev_info(ModInfo,   mod, hi_show_module_info);
      case PROCESSOR:
            dev_info(CPUDevice, cpu, hi_show_cpu_info);
      case PCI:
            dev_info(PCIDevice, pci, hi_show_pci_info);
      case ISAPnP:
            dev_info(ISADevice, isa, hi_show_isa_info);
      case USB:
            dev_info(USBDevice, usb, hi_show_usb_info);
      case SERIAL:
            dev_info(SerialDevice, serial, hi_show_serial_info);
      case PARPORT:
            dev_info(ParportDevice, parport, hi_show_parport_info);
      case IDE:
            dev_info(IDEDevice, ide, hi_show_ide_info);
      case SCSI:
            dev_info(SCSIDevice, scsi, hi_show_scsi_info);
      case V4L:
            dev_info(V4LDevice, v4l, hi_show_v4l_info);
      default:
            g_print("Showing info of device type %d not implemented yet.\n",
                  dev->type);
            return;
            break;
      }
}

void
hi_scan_all(MainWindow * mainwindow)
{
      myStatus    *status;
      PCIDevice   *pci; 
      ISADevice   *isa; 
      IDEDevice   *ide;
      CPUDevice   *cpu;
      SCSIDevice  *scsi;
      V4LDevice   *v4l;
      ParportDevice     *pp;
      SerialDevice      *sd;
      GtkCTreeNode      *node;
      ModInfo           *mod;
      GenericDevice     *gd = generic_devices;
      gchar       *buf;

      status = my_status_new(_("Scanning Devices"), _("Scanning devices..."));

#define DEVICE_SCAN(name,ptr,func) \
            ptr = func(); \
            buf = g_strdup_printf(_("Scanning %s devices..."), name); \
            my_status_set_text(status, buf); \
            g_free(buf); \
            my_status_pulse(status)
      
      DEVICE_SCAN("CPU",      cpu,  computer_get_info);
      DEVICE_SCAN("PCI",      pci,  hi_scan_pci);
      DEVICE_SCAN("ISA PnP",  isa,  hi_scan_isapnp);
      DEVICE_SCAN("IDE",      ide,  hi_scan_ide);
      DEVICE_SCAN("SCSI",     scsi, hi_scan_scsi);
      DEVICE_SCAN("V4L",      v4l,  hi_scan_v4l);
      DEVICE_SCAN("Parallel", pp,   hi_scan_parport);
      DEVICE_SCAN("Serial",   sd,   hi_scan_serial);
      DEVICE_SCAN("modules",  mod,  hi_scan_modules);

      gtk_clist_freeze(GTK_CLIST(mainwindow->ctree));

      /*
       * Free the generic_devices stuff and remove all device-related
       * nodes.
       */
      if (gd != NULL) {
            for (; gd != NULL; gd = gd->next) {
                  g_free(gd->device);
                  gtk_ctree_remove_node(GTK_CTREE(mainwindow->ctree),
                                    gd->node);
                  g_free(gd);
            }
            generic_devices = NULL;
      }
      
#define CHECK_INSERT(a,b,c,d) \
      if (a) { \
            node = tree_group_new(mainwindow, b, c); \
            for (; a != NULL; a = a->next) { \
                  if (a->d) { \
                        hi_insert_generic(a, c); \
                        tree_insert_item(mainwindow, node, a->d, \
                              generic_devices); \
                  } \
            } \
      }


      /*
       * Processor info
       */
      node = tree_group_new(mainwindow, _("Processor"), PROCESSOR);
      hi_insert_generic(cpu, PROCESSOR);
      tree_insert_item(mainwindow, node, cpu->processor, generic_devices);

      CHECK_INSERT(pci, _("PCI Devices"), PCI, name);
      CHECK_INSERT(isa, _("ISA PnP Devices"), ISAPnP, card);

      /*
       * USB is different since it's Plug'n'Pray, so we have a
       * routine just for it :)
       */
      usb_update(mainwindow);

      CHECK_INSERT(ide, _("ATA/IDE Block Devices"), IDE, model);
      CHECK_INSERT(scsi, _("SCSI Devices"), SCSI, model);
      CHECK_INSERT(v4l, _("Video for Linux"), V4L, name);
      CHECK_INSERT(sd, _("Communication Ports"), SERIAL, name);
      CHECK_INSERT(pp, _("Parallel Ports"), PARPORT, name);
 
      CHECK_INSERT(mod, _("Kernel Modules"), MODULE, description);
      
      gtk_clist_thaw(GTK_CLIST(mainwindow->ctree));

      my_status_destroy(status);
}

static void
usage(char *argv0)
{
      g_print("%s [--help] [--prefix <prefix>]\n", argv0);
      exit(1);
}

int
main(int argc, char **argv)
{
      MainWindow *mainwindow;
      gint i;

#ifdef ENABLE_NLS
      intl_init();
#endif

      g_print("HardInfo " VERSION);
      if (strstr(VERSION, "pre")) {
            g_print(" *** PRE-RELEASE ***");
      }
      g_print
          ("\nCopyright (c) 2003 Leandro Pereira <leandro@linuxmag.com.br>\n\n");
      g_print(_
            ("This is free software; you can modify and/or distribute it\n"));
      g_print(_
            ("under the terms of GNU GPL version 2. See http://www.fsf.org/\n"));
      g_print(_("for more information.\n\n"));

      gtk_init(&argc, &argv);

      hi_stock_init();

      for (i = 1; i < argc; i++) {
            if (!strncmp(argv[i], "--help", 6) ||
                !strncmp(argv[i], "-h", 2)) {
                  usage(argv[0]);
            } else
                if (!strncmp(argv[i], "--prefix", 8) ||
                  !strncmp(argv[i], "-p", 2)) {
                  i++;
                  if (argv[i][0] == '-')
                        usage(argv[0]);

                  g_print("prefix = %s\n", argv[i]);
            }
      }

      mainwindow = main_window_create();
      main_window_refresh(NULL, mainwindow);

      gtk_main();

      return 0;
}

Generated by  Doxygen 1.6.0   Back to index