dockapps/wmsupermon/wmsupermon.c

/* Copyright (C) 2006 Sergei Golubchik, Nicolas Chauvat

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License version 2
   as published by the Free Software Foundation

   This program 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 this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */

/*
  originally based on
    WMgMon - Window Maker Generic Monitor
    by Nicolas Chauvat <nico@caesium.fr>
  which was based on
    WMMon by Antoine Nulle and Martijn
*/

#define Wmsupermon_VERSION "1.2.2"
#define Wmsupermon_VERSION_DATE "2007/06/23"

#include <unistd.h>
#include <time.h>
#include <ctype.h>
#include <regex.h>
#include <assert.h>

#include "dockapp.h"
#include "wmsupermon-master.xpm"
#include "expr.h"
#include "stat_dev.h"
#include "panes.h"

/* define layout constants */
#define ROW_HEIGHT 14
#define LABEL_WIDTH 25

/******************************************************************************/
/* master xpm coordinates                                                     */
/******************************************************************************/

#define X_ALPHA 1
#define Y_ALPHA 1
#define X_NUM   1
#define Y_NUM  11

#define X_LABEL  1
#define Y_LABEL 21
#define W_LABEL 56
#define H_LABEL (ROW_HEIGHT-1)

#define X_NOLABEL  1
#define Y_NOLABEL 77
#define W_NOLABEL W_LABEL
#define H_NOLABEL H_LABEL

#define X_DIAG  1
#define Y_DIAG 34
#define W_DIAG W_LABEL
#define H_SDIAG (ROW_HEIGHT*1)
#define H_MDIAG (ROW_HEIGHT*2)
#define H_DIAG  (ROW_HEIGHT*3)
#define H_BDIAG (ROW_HEIGHT*4)

#define X_BLANK_SBAR (118-2)
#define Y_BLANK_SBAR (127-50)
#define X_SBAR  (118-2)
#define Y_SBAR  (138-50)
#define W_SBAR  30
#define H_SBAR  10
#define X_BLANK_LBAR (62-2)
#define Y_BLANK_LBAR (127-50)
#define X_LBAR  (62-2)
#define Y_LBAR  (138-50)
#define W_LBAR  54
#define H_LBAR  H_SBAR

#define X_DOT      150
#define COLOR_DOT   27
#define BRIGHT_DOT  28
#define BACK_DOT    29
#define LINE_DOT    30

/******************************************************************************/
/* global variables                                                           */
/******************************************************************************/

Pixmap work_pixmap, master_pixmap;
GC gc;

char *displayName="", *config=0;

static DAProgramOption options[]={
    {"-d", "--display", "display to use", DOString, False, {&displayName} },
    {"-c", "--config",  "path to config file", DOString, False, {&config} }
};

#define WIND_MAX 4
wind_desc winds[WIND_MAX];

/* define panes */
#define PANE_MAX (8*WIND_MAX)
pane_desc pane[PANE_MAX];

int rotate_interval=4;
int next_rotate=0;
int current_time=0;
int wind_num=0;

#define STAT_DEV_MAX 20
stat_dev stat_device[STAT_DEV_MAX];

#define APP_WIDTH  56
#define APP_HEIGHT 56

/******************************************************************************/
/* prototypes                                                                 */
/******************************************************************************/

void draw_label(const char *, int, int);
void draw_bar(pane_part *, int, int);
void draw_graph(pane_part *, int, int, int, int);
void draw_current_frame(pane_part *);
void draw_current_pane(pane_part *);

static void click(Window w, int button, int state, int x, int y);

char mask_bits[APP_HEIGHT*APP_WIDTH];

/******************************************************************************/
/* main                                                                       */
/******************************************************************************/

int main (int argc, char *argv[])
{
  unsigned w, h;
  int i, device_num=0, pane_num=0;
  DACallbacks callbacks={ NULL, &click, NULL, NULL, NULL, NULL, NULL };

  DAParseArguments(argc, argv, options,
                   sizeof(options)/sizeof(DAProgramOption),
                   "wmsupermon", Wmsupermon_VERSION);

  /* init structures */
  for (i=0; i<STAT_DEV_MAX; i++)
    stat_dev_init(&stat_device[i]);

  /* read config file and populate structures */
  i=read_config_file(pane, &pane_num, PANE_MAX,
                     stat_device, &device_num, STAT_DEV_MAX,
                     winds, &wind_num, WIND_MAX);
  if (i < 0) /* error in config file */
    exit(1);
  if (i > 0) /* no config file */
    exit(2); /* TODO: setup default panes */

  /* init timing stuff */
  next_rotate=time(0) + rotate_interval;

  for (i=0; i<device_num; i++)
    stat_dev_initstat(&stat_device[i]);


  for (i=0; i < wind_num; i++) {
    DAInitialize(displayName, winds[i].name, APP_WIDTH, APP_HEIGHT, argc, argv, winds[i].w);
    DASetCallbacks(winds[i].w, &callbacks);

    winds[i].pixmap=work_pixmap=DAMakePixmap(winds[i].w);
    DAMakePixmapFromData(winds[i].w, wmsupermon_master_xpm, &master_pixmap, 0, &w, &h);

    DAShow(winds[i].w);
    winds[i].cur_pane=0;
  }

  gc=DefaultGC(DADisplay, DefaultScreen(DADisplay));

  XSetForeground(DADisplay, gc, BlackPixel(DADisplay, DefaultScreen(DADisplay)));

  for (i=0; i < wind_num; i++) {
    XFillRectangle(DADisplay, work_pixmap=winds[i].pixmap, gc, 0, 0, APP_WIDTH, APP_HEIGHT);
    draw_current_frame(winds[i].panes[winds[i].cur_pane]);
    winds[i].mask=XCreateBitmapFromData(DADisplay, winds[i].w[0], mask_bits, APP_WIDTH, APP_HEIGHT);
    DASetShape(winds[i].w, winds[i].mask);
  }

  /* mainloop */
  while (1) {
    XEvent ev;

    current_time=time(0);

    /* change pane ? */
    if (current_time > next_rotate) {
      next_rotate=current_time+rotate_interval;
      for (i=0; i < wind_num; i++) {
        if (winds[i].num_panes > 1) {
          winds[i].cur_pane++;
          if (winds[i].cur_pane >= winds[i].num_panes)
            winds[i].cur_pane=0;
          /* redraw frame */
          work_pixmap=winds[i].pixmap;
          draw_current_frame(winds[i].panes[winds[i].cur_pane]);
          XFreePixmap(DADisplay, winds[i].mask);
          winds[i].mask=XCreateBitmapFromData(DADisplay, winds[i].w[0], mask_bits, APP_WIDTH, APP_HEIGHT);
          DASetShape(winds[i].w, winds[i].mask);
        }
      }
    }

    for (i=0; i < device_num; i++) {
      stat_dev *st=&stat_device[i];
      /* if time has come, update stats */
      if  (current_time >= st->next_update) {
        int j;
        history **h=st->hist;
        update_stat(st);
        if (st->smooth) {
          double v=st->smooth[0];
          for (j=0; j < SMOOTH_SIZE-2; j++)
            v+=(st->smooth[j]=st->smooth[j+1]);
          v+=(st->smooth[j]=st->value[0]);
          st->value[1]=v/SMOOTH_SIZE;
        }
        for (j=0; j <= P_HIST; j++, h++) {
          if (!*h) continue;
          (*h)->data[HIST_LAST]+= st->value[j & P_SMOOTH];
          (*h)->count++;
        }
        st->next_update=current_time+st->update_interval;
      }
      /* if time has come, update history */
      if  (current_time > st->hist_next_update) {
        stat_dev_update_history(st);
        if (st->hist_next_update < current_time)
          st->hist_next_update=current_time;
        st->hist_next_update+=st->hist_update_interval;
      }
    }

    /* update view */
    for (i=0; i < wind_num; i++) {
      work_pixmap=winds[i].pixmap;
      draw_current_pane(winds[i].panes[winds[i].cur_pane]);
      XCopyArea(DADisplay, work_pixmap, winds[i].w[0], gc, 0, 0,
          APP_WIDTH, APP_HEIGHT, 0, 0);
    }

    /* handle all pending X events */
    while (XPending(DADisplay)) {
      XNextEvent(DADisplay, &ev);
      for (i=0; i < wind_num; i++)
        DAProcessEvent(winds[i].w, &ev);
    }

    /* short sleep */
    usleep(250000L);

  }

  return 0;
}

/******************************************************************************/
/* mouse events / callbacks                                                   */
/******************************************************************************/

static void click(Window w, int button, int state, int x, int y)
{
  pane_part *pane;
  int p=y, i;
  for (i=0; i < wind_num; i++) {
    if (winds[i].w[0] != w) continue;
    pane=winds[i].panes[winds[i].cur_pane];

    for (p=0; pane[p].stat && p < PANE_PARTS; p++)
      if ((y-= ROW_HEIGHT*pane[p].height) < 0) break;
    if (y < 0 && pane[p].stat->action)
      if (!fork()) {
        system(pane[p].stat->action);
        exit(0);
      }
    break;
  }
}

/******************************************************************************/
/* draw functions                                                             */
/******************************************************************************/

void copy_area(int src_x, int src_y, int width, int height, int d_x, int d_y)
{
  XCopyArea(DADisplay, master_pixmap, work_pixmap, gc,
    src_x, src_y, width, height, d_x, d_y);
}

void draw_current_frame(pane_part *pane)
{
  int i, j;
  int row=0;

  XSetForeground(DADisplay, gc, BlackPixel(DADisplay, DefaultScreen(DADisplay)));
  XFillRectangle(DADisplay, work_pixmap, gc, 0, 0, APP_WIDTH, APP_HEIGHT);

  for (j=0; j < sizeof(mask_bits); j++) mask_bits[j]=0xff;
  for (i=0; (row<PANE_PARTS) && (i<PANE_MAX) && pane[i].stat; i++) {
    switch(pane[i].height) {
    case 1:
       if (pane[i].flags & P_LABEL) {
         copy_area (X_LABEL, Y_LABEL, W_LABEL, H_LABEL, 0, row*ROW_HEIGHT);
         draw_label(pane[i].stat->name, 1, 2+row*ROW_HEIGHT);
         for (j=0; j < ROW_HEIGHT; j++)
           mask_bits[(row*ROW_HEIGHT+j)*W_LABEL/8+(LABEL_WIDTH-3)/8] &=
             ~(1 << (LABEL_WIDTH-3) % 8);
       } else
         copy_area (X_NOLABEL, Y_NOLABEL, W_NOLABEL, H_NOLABEL, 0, row*ROW_HEIGHT);
       break;
    case 2:
      copy_area (X_DIAG, Y_DIAG, W_DIAG, H_MDIAG-5, 0, row*ROW_HEIGHT);
      copy_area (X_DIAG, Y_DIAG+H_DIAG-H_MDIAG+5, W_DIAG, H_MDIAG-5, 0, row*ROW_HEIGHT+5);
      break;
    case 3:
      copy_area (X_DIAG, Y_DIAG, W_DIAG, H_DIAG, 0, row*ROW_HEIGHT);
      break;
    case 4:
      copy_area (X_DIAG, Y_DIAG, W_DIAG, H_DIAG-5, 0, row*ROW_HEIGHT);
      copy_area (X_DIAG, Y_DIAG+5, W_DIAG, H_DIAG-5, 0, row*ROW_HEIGHT+H_BDIAG-H_DIAG+5);
      break;
    default:
      assert(0);
    }
    row+=pane[i].height;
    for (j=0; j < W_LABEL/8; j++) mask_bits[(row*ROW_HEIGHT-1)*W_LABEL/8+j]=0;
  }
}

static struct { int w,h; } graph_box[]=
{
  {0,0},
  {W_DIAG-2, H_SDIAG-2},
  {W_DIAG-2, H_MDIAG-2},
  {W_DIAG-2, H_DIAG-2},
  {W_DIAG-2, H_BDIAG-2}
};

void draw_current_pane(pane_part *pane)
{
  int i;
  int row=0, label_width;
  char str[6]={0};

  for (i=0; (row<PANE_PARTS) && pane->stat; pane++, i++) {
    label_width=pane->flags & P_LABEL && pane->height == 1 ?
                LABEL_WIDTH-1 : 0;
    switch(pane->type) {
    case PTBar:
      draw_bar(pane, label_width+1, 1+row*ROW_HEIGHT);
      break;
    case PTPercent:
      sprintf(str, " %*.*f%%", label_width ? 2 : 5, label_width ? 0 : 2,
          100*pane->stat->value[pane->flags & P_SMOOTH]);
      draw_label(str, label_width+4, 2+row*ROW_HEIGHT);
      break;
    case PTNumber:
      sprintf(str,
          pane->flags & P_FLOAT ? "%2$*1$.*1$g" : "%2$*1$.0f",
          label_width ? 4 : 6, pane->stat->value[pane->flags & P_SMOOTH]);
      draw_label(str, label_width+4, 2+row*ROW_HEIGHT);
      break;
    case PTGraph:
      draw_graph(pane, label_width+1, 1+row*ROW_HEIGHT,
          graph_box[pane->height].w-label_width,
          graph_box[pane->height].h);
      if (pane->flags & P_LABEL && pane->height > 1)
        draw_label(pane->stat->name, 1, 1+row*ROW_HEIGHT);
      break;
    default:
      assert(0);
      break;
    }
    row+=pane->height;
  }
}

void draw_label(const char *str, int x, int y)
{
  int i, c;

  for (i=0; str[i] != '\0'; i++) {
    if (isalnum(str[i])) {
      c=toupper(str[i]);
      if (c >= 'A' && c <= 'Z') {
        c -= 'A';
        copy_area(X_ALPHA+c*6, Y_ALPHA, 6, 8, x+i*6, y);
      }
      else {
        c -= '0';
        copy_area(X_NUM+c*6, Y_NUM, 6, 8, x+i*6, y);
      }
    }
    else {
      switch(str[i]) {
      case '/' :
        copy_area(72-2, 61-50, 6, 8, x+i*6, y);
        break;
      case '.' :
        copy_area(84-2, 61-50, 6, 8, x+i*6, y);
        break;
      case '%' :
        copy_area(66-2, 61-50, 6, 8, x+i*6, y);
        break;
      case '-' :
        copy_area(89-2, 61-50, 6, 8, x+i*6, y);
        break;
      default:
        copy_area(78-2, 61-50, 6, 8, x+i*6, y);
      }
    }
  }
}

static const struct {
  int x_blank, y_blank, x, y, h, w;
} bar_coords[]={
  {X_BLANK_SBAR, Y_BLANK_SBAR, X_SBAR, Y_SBAR, H_SBAR, W_SBAR},
  {X_BLANK_LBAR, Y_BLANK_LBAR, X_LBAR, Y_LBAR, H_LBAR, W_LBAR}
};

void draw_bar (pane_part *widget, int x, int y)
{
  stat_dev *st=widget->stat;
  int value;
  int label= x==1;

   /* copy blank bar */
   copy_area(bar_coords[label].x_blank, bar_coords[label].y_blank,
             bar_coords[label].w, bar_coords[label].h, x, y);

   /* compute value */
   if (st->max)
     value=(st->value[widget->flags & P_SMOOTH]-st->min)/st->max *
           bar_coords[label].w;
   else
     value=st->value[widget->flags & P_SMOOTH] * bar_coords[label].w;
   if (value > bar_coords[label].w)
      value=bar_coords[label].w;
   if (value < 0)
      value=0;

   /* copy part of color bar */
   copy_area(bar_coords[label].x, bar_coords[label].y,
       value, bar_coords[label].h, x, y);
}

/* Below: (0) - to disable, (st->max) to enable */
#define USER_RANGE (st->max)
void draw_graph (pane_part *widget, int x, int y, int width, int height)
{
   stat_dev *st=widget->stat;
   int row, column, top, x0, y0;
   history *hist=st->hist[widget->flags & P_HIST];

   x0=width - HIST_LAST + x;
   y0=y + height - 1;

   if (!USER_RANGE) {
     /* compute scale */
     if (widget->flags & P_SCALEDOWN) {
        double hist_max=0;
        for (column=HIST_LAST-width; column < HIST_LAST; column++) {
           if (hist->data[column] > hist_max)
              hist_max=hist->data[column];
        }
        if (hist_max > 0)
          hist->max=hist_max;
     }
     else if (hist->data[HIST_LAST-1] > hist->max)
       hist->max=hist->data[HIST_LAST-1];
   }
   /* draw bars (top is lighter) */
   for (column=HIST_LAST-width; column < HIST_LAST; column++) {
     if (USER_RANGE)
       top=(hist->data[column] - st->min) * height / st->max;
     else
       top=hist->data[column] * height / hist->max;

       for (row=0; row < height; row++) {
         if (row < top - 3)
           copy_area (X_DOT, COLOR_DOT, 1, 1, x0+column, y0-row);
         else if (row < top)
           copy_area (X_DOT, BRIGHT_DOT, 1, 1, x0+column, y0-row);
         else
           copy_area (X_DOT, BACK_DOT, 1, 1, x0+column, y0-row);
      }
   }
}
#undef USER_RANGE