Imported Upstream version 2.0.0upstream/2.0.0

1 files changed, 115 insertions, 104 deletions

diff --git a/Header.c b/Header.c
index 5558684..929a6e0 100644
--- a/Header.c
+++ b/Header.c
@@ -8,16 +8,8 @@ in the source distribution for its full text.
 #include "Header.h"
 
 #include "CRT.h"
-#include "CPUMeter.h"
-#include "MemoryMeter.h"
-#include "SwapMeter.h"
-#include "TasksMeter.h"
-#include "LoadAverageMeter.h"
-#include "UptimeMeter.h"
-#include "BatteryMeter.h"
-#include "ClockMeter.h"
-#include "HostnameMeter.h"
-#include "String.h"
+#include "StringUtils.h"
+#include "Platform.h"
 
 #include <assert.h>
 #include <time.h>
@@ -25,21 +17,17 @@ in the source distribution for its full text.
 #include <stdlib.h>
 
 /*{
-#include "ProcessList.h"
 #include "Meter.h"
-
-typedef enum HeaderSide_ {
-   LEFT_HEADER,
-   RIGHT_HEADER
-} HeaderSide;
+#include "Settings.h"
+#include "Vector.h"
 
 typedef struct Header_ {
-   Vector* leftMeters;
-   Vector* rightMeters;
-   ProcessList* pl;
-   int height;
+   Vector** columns;
+   Settings* settings;
+   struct ProcessList_* pl;
+   int nrColumns;
    int pad;
-   bool margin;
+   int height;
 } Header;
 
 }*/
@@ -48,25 +36,73 @@ typedef struct Header_ {
 #define MAX(a,b) ((a)>(b)?(a):(b))
 #endif
 
-Header* Header_new(ProcessList* pl) {
-   Header* this = calloc(1, sizeof(Header));
-   this->leftMeters = Vector_new(Class(Meter), true, DEFAULT_SIZE);
-   this->rightMeters = Vector_new(Class(Meter), true, DEFAULT_SIZE);
-   this->margin = true;
+#ifndef Header_forEachColumn
+#define Header_forEachColumn(this_, i_) for (int i_=0; i_ < this->nrColumns; i_++)
+#endif
+
+Header* Header_new(struct ProcessList_* pl, Settings* settings, int nrColumns) {
+   Header* this = xCalloc(1, sizeof(Header));
+   this->columns = xCalloc(nrColumns, sizeof(Vector*));
+   this->settings = settings;
    this->pl = pl;
+   this->nrColumns = nrColumns;
+   Header_forEachColumn(this, i) {
+      this->columns[i] = Vector_new(Class(Meter), true, DEFAULT_SIZE);
+   }
    return this;
 }
 
 void Header_delete(Header* this) {
-   Vector_delete(this->leftMeters);
-   Vector_delete(this->rightMeters);
+   Header_forEachColumn(this, i) {
+      Vector_delete(this->columns[i]);
+   }
+   free(this->columns);
    free(this);
 }
 
-void Header_createMeter(Header* this, char* name, HeaderSide side) {
-   Vector* meters = side == LEFT_HEADER
-                       ? this->leftMeters
-                       : this->rightMeters;
+void Header_populateFromSettings(Header* this) {
+   Header_forEachColumn(this, col) {
+      MeterColumnSettings* colSettings = &this->settings->columns[col];
+      for (int i = 0; i < colSettings->len; i++) {
+         Header_addMeterByName(this, colSettings->names[i], col);
+         if (colSettings->modes[i] != 0) {
+            Header_setMode(this, i, colSettings->modes[i], col);
+         }
+      }
+   }
+   Header_calculateHeight(this);
+}
+
+void Header_writeBackToSettings(const Header* this) {
+   Header_forEachColumn(this, col) {
+      MeterColumnSettings* colSettings = &this->settings->columns[col];
+      
+      String_freeArray(colSettings->names);
+      free(colSettings->modes);
+      
+      Vector* vec = this->columns[col];
+      int len = Vector_size(vec);
+      
+      colSettings->names = xCalloc(len+1, sizeof(char*));
+      colSettings->modes = xCalloc(len, sizeof(int));
+      colSettings->len = len;
+      
+      for (int i = 0; i < len; i++) {
+         Meter* meter = (Meter*) Vector_get(vec, i);
+         char* name = xCalloc(64, sizeof(char));
+         if (meter->param) {
+            snprintf(name, 63, "%s(%d)", As_Meter(meter)->name, meter->param);
+         } else {
+            snprintf(name, 63, "%s", As_Meter(meter)->name);
+         }
+         colSettings->names[i] = name;
+         colSettings->modes[i] = meter->mode;
+      }
+   }
+}
+
+MeterModeId Header_addMeterByName(Header* this, char* name, int column) {
+   Vector* meters = this->columns[column];
 
    char* paren = strchr(name, '(');
    int param = 0;
@@ -75,18 +111,20 @@ void Header_createMeter(Header* this, char* name, HeaderSide side) {
       if (!ok) param = 0;
       *paren = '\0';
    }
-   for (MeterClass** type = Meter_types; *type; type++) {
+   MeterModeId mode = TEXT_METERMODE;
+   for (MeterClass** type = Platform_meterTypes; *type; type++) {
       if (String_eq(name, (*type)->name)) {
-         Vector_add(meters, Meter_new(this->pl, param, *type));
+         Meter* meter = Meter_new(this->pl, param, *type);
+         Vector_add(meters, meter);
+         mode = meter->mode;
          break;
       }
    }
+   return mode;
 }
 
-void Header_setMode(Header* this, int i, MeterModeId mode, HeaderSide side) {
-   Vector* meters = side == LEFT_HEADER
-                       ? this->leftMeters
-                       : this->rightMeters;
+void Header_setMode(Header* this, int i, MeterModeId mode, int column) {
+   Vector* meters = this->columns[column];
 
    if (i >= Vector_size(meters))
       return;
@@ -94,33 +132,26 @@ void Header_setMode(Header* this, int i, MeterModeId mode, HeaderSide side) {
    Meter_setMode(meter, mode);
 }
 
-Meter* Header_addMeter(Header* this, MeterClass* type, int param, HeaderSide side) {
-   Vector* meters = side == LEFT_HEADER
-                       ? this->leftMeters
-                       : this->rightMeters;
+Meter* Header_addMeterByClass(Header* this, MeterClass* type, int param, int column) {
+   Vector* meters = this->columns[column];
 
    Meter* meter = Meter_new(this->pl, param, type);
    Vector_add(meters, meter);
    return meter;
 }
 
-int Header_size(Header* this, HeaderSide side) {
-   Vector* meters = side == LEFT_HEADER
-                       ? this->leftMeters
-                       : this->rightMeters;
-
+int Header_size(Header* this, int column) {
+   Vector* meters = this->columns[column];
    return Vector_size(meters);
 }
 
-char* Header_readMeterName(Header* this, int i, HeaderSide side) {
-   Vector* meters = side == LEFT_HEADER
-                       ? this->leftMeters
-                       : this->rightMeters;
+char* Header_readMeterName(Header* this, int i, int column) {
+   Vector* meters = this->columns[column];
    Meter* meter = (Meter*) Vector_get(meters, i);
 
    int nameLen = strlen(Meter_name(meter));
    int len = nameLen + 100;
-   char* name = malloc(len);
+   char* name = xMalloc(len);
    strncpy(name, Meter_name(meter), nameLen);
    name[nameLen] = '\0';
    if (meter->param)
@@ -129,42 +160,20 @@ char* Header_readMeterName(Header* this, int i, HeaderSide side) {
    return name;
 }
 
-MeterModeId Header_readMeterMode(Header* this, int i, HeaderSide side) {
-   Vector* meters = side == LEFT_HEADER
-                       ? this->leftMeters
-                       : this->rightMeters;
+MeterModeId Header_readMeterMode(Header* this, int i, int column) {
+   Vector* meters = this->columns[column];
 
    Meter* meter = (Meter*) Vector_get(meters, i);
    return meter->mode;
 }
 
-void Header_defaultMeters(Header* this, int cpuCount) {
-   if (cpuCount > 8) {
-      Vector_add(this->leftMeters, Meter_new(this->pl, 0, (MeterClass*) Class(LeftCPUs2Meter)));
-      Vector_add(this->rightMeters, Meter_new(this->pl, 0, (MeterClass*) Class(RightCPUs2Meter)));
-   } else if (cpuCount > 4) {
-      Vector_add(this->leftMeters, Meter_new(this->pl, 0, (MeterClass*) Class(LeftCPUsMeter)));
-      Vector_add(this->rightMeters, Meter_new(this->pl, 0, (MeterClass*) Class(RightCPUsMeter)));
-   } else {
-      Vector_add(this->leftMeters, Meter_new(this->pl, 0, (MeterClass*) Class(AllCPUsMeter)));
-   }
-   Vector_add(this->leftMeters, Meter_new(this->pl, 0, (MeterClass*) Class(MemoryMeter)));
-   Vector_add(this->leftMeters, Meter_new(this->pl, 0, (MeterClass*) Class(SwapMeter)));
-   Vector_add(this->rightMeters, Meter_new(this->pl, 0, (MeterClass*) Class(TasksMeter)));
-   Vector_add(this->rightMeters, Meter_new(this->pl, 0, (MeterClass*) Class(LoadAverageMeter)));
-   Vector_add(this->rightMeters, Meter_new(this->pl, 0, (MeterClass*) Class(UptimeMeter)));
-}
-
 void Header_reinit(Header* this) {
-   for (int i = 0; i < Vector_size(this->leftMeters); i++) {
-      Meter* meter = (Meter*) Vector_get(this->leftMeters, i);
-      if (Meter_initFn(meter))
-         Meter_init(meter);
-   }
-   for (int i = 0; i < Vector_size(this->rightMeters); i++) {
-      Meter* meter = (Meter*) Vector_get(this->rightMeters, i);
-      if (Meter_initFn(meter))
-         Meter_init(meter);
+   Header_forEachColumn(this, col) {
+      for (int i = 0; i < Vector_size(this->columns[col]); i++) {
+         Meter* meter = (Meter*) Vector_get(this->columns[col], i);
+         if (Meter_initFn(meter))
+            Meter_init(meter);
+      }
    }
 }
 
@@ -175,32 +184,34 @@ void Header_draw(const Header* this) {
    for (int y = 0; y < height; y++) {
       mvhline(y, 0, ' ', COLS);
    }
-   for (int y = (pad / 2), i = 0; i < Vector_size(this->leftMeters); i++) {
-      Meter* meter = (Meter*) Vector_get(this->leftMeters, i);
-      meter->draw(meter, pad, y, COLS / 2 - (pad * 2 - 1) - 1);
-      y += meter->h;
-   }
-   for (int y = (pad / 2), i = 0; i < Vector_size(this->rightMeters); i++) {
-      Meter* meter = (Meter*) Vector_get(this->rightMeters, i);
-      meter->draw(meter, COLS / 2 + pad, y, COLS / 2 - (pad * 2 - 1) - 1);
-      y += meter->h;
+   int width = COLS / this->nrColumns - (pad * this->nrColumns - 1) - 1;
+   int x = pad;
+   
+   Header_forEachColumn(this, col) {
+      Vector* meters = this->columns[col];
+      for (int y = (pad / 2), i = 0; i < Vector_size(meters); i++) {
+         Meter* meter = (Meter*) Vector_get(meters, i);
+         meter->draw(meter, x, y, width);
+         y += meter->h;
+      }
+      x += width + pad;
    }
 }
 
 int Header_calculateHeight(Header* this) {
-   int pad = this->margin ? 2 : 0;
-   int leftHeight = pad;
-   int rightHeight = pad;
-
-   for (int i = 0; i < Vector_size(this->leftMeters); i++) {
-      Meter* meter = (Meter*) Vector_get(this->leftMeters, i);
-      leftHeight += meter->h;
-   }
-   for (int i = 0; i < Vector_size(this->rightMeters); i++) {
-      Meter* meter = (Meter*) Vector_get(this->rightMeters, i);
-      rightHeight += meter->h;
+   int pad = this->settings->headerMargin ? 2 : 0;
+   int maxHeight = pad;
+
+   Header_forEachColumn(this, col) {
+      Vector* meters = this->columns[col];
+      int height = pad;
+      for (int i = 0; i < Vector_size(meters); i++) {
+         Meter* meter = (Meter*) Vector_get(meters, i);
+         height += meter->h;
+      }
+      maxHeight = MAX(maxHeight, height);
    }
+   this->height = maxHeight;
    this->pad = pad;
-   this->height = MAX(leftHeight, rightHeight);
-   return this->height;
+   return maxHeight;
 }