Initial import.

ColumnsListBox.h

+/* Do not edit this file. It was automatically genarated. */
+
+#ifndef HEADER_ColumnsListBox
+#define HEADER_ColumnsListBox
+
+
+#include "ListBox.h"
+#include "Settings.h"
+#include "ScreenManager.h"
+
+#include "debug.h"
+#include <assert.h>
+
+
+typedef struct ColumnsListBox_ {
+   ListBox super;
+
+   Settings* settings;
+   TypedVector* columns;
+   ScreenManager* scr;
+} ColumnsListBox;
+
+
+ColumnsListBox* ColumnsListBox_new(Settings* settings, ScreenManager* scr);
+
+void ColumnsListBox_delete(Object* object);
+
+void ColumnsListBox_update(ListBox* super);
+
+HandlerResult ColumnsListBox_eventHandler(ListBox* super, int ch);
+
+#endif

DebugMemory.c

+
+#define _GNU_SOURCE
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include <assert.h>
+
+#include "DebugMemory.h"
+
+#undef strdup
+#undef malloc
+#undef realloc
+#undef calloc
+#undef free
+
+/*{
+typedef struct DebugMemoryItem_ DebugMemoryItem;
+
+struct DebugMemoryItem_ {
+   void* data;
+   char* file;
+   int line;
+   DebugMemoryItem* next;
+};
+
+typedef struct DebugMemory_ {
+   DebugMemoryItem* first;
+   int allocations;
+   int deallocations;
+   int size;
+   FILE* file;
+} DebugMemory;
+}*/
+
+/* private property */
+DebugMemory* singleton = NULL;
+
+void DebugMemory_new() {
+   if (singleton)
+      return;
+   singleton = malloc(sizeof(DebugMemory));
+   singleton->first = NULL;
+   singleton->allocations = 0;
+   singleton->deallocations = 0;
+   singleton->size = 0;
+   singleton->file = fopen("/tmp/htop-debug-alloc.txt", "w");
+}
+
+void* DebugMemory_malloc(int size, char* file, int line) {
+   void* data = malloc(size);
+   DebugMemory_registerAllocation(data, file, line);
+   fprintf(singleton->file, "%d\t%s:%d\n", size, file, line);
+   return data;
+}
+
+void* DebugMemory_calloc(int a, int b, char* file, int line) {
+   void* data = calloc(a, b);
+   DebugMemory_registerAllocation(data, file, line);
+   fprintf(singleton->file, "%d\t%s:%d\n", a*b, file, line);
+   return data;
+}
+
+void* DebugMemory_realloc(void* ptr, int size, char* file, int line) {
+   if (ptr != NULL)
+      DebugMemory_registerDeallocation(ptr, file, line);
+   void* data = realloc(ptr, size);
+   DebugMemory_registerAllocation(data, file, line);
+   fprintf(singleton->file, "%d\t%s:%d\n", size, file, line);
+   return data;
+}
+
+void* DebugMemory_strdup(char* str, char* file, int line) {
+   char* data = strdup(str);
+   DebugMemory_registerAllocation(data, file, line);
+   fprintf(singleton->file, "%d\t%s:%d\n", (int) strlen(str), file, line);
+   return data;
+}
+
+void DebugMemory_free(void* data, char* file, int line) {
+   DebugMemory_registerDeallocation(data, file, line);
+   free(data);
+}
+
+void DebugMemory_assertSize() {
+   if (!singleton->first) {
+      assert (singleton->size == 0);
+   }
+   DebugMemoryItem* walk = singleton->first;
+   int i = 0;
+   while (walk != NULL) {
+      i++;
+      walk = walk->next;
+   }
+   assert (i == singleton->size);
+}
+
+int DebugMemory_getBlockCount() {
+   if (!singleton->first) {
+      return 0;
+   }
+   DebugMemoryItem* walk = singleton->first;
+   int i = 0;
+   while (walk != NULL) {
+      i++;
+      walk = walk->next;
+   }
+   return i;
+}
+
+void DebugMemory_registerAllocation(void* data, char* file, int line) {
+   if (!singleton)
+      DebugMemory_new();
+   DebugMemory_assertSize();
+   DebugMemoryItem* item = (DebugMemoryItem*) malloc(sizeof(DebugMemoryItem));
+   item->data = data;
+   item->file = file;
+   item->line = line;
+   item->next = NULL;
+   int val = DebugMemory_getBlockCount();
+   if (singleton->first == NULL) {
+      assert (val == 0);
+      singleton->first = item;
+   } else {
+      DebugMemoryItem* walk = singleton->first;
+      while (true) {
+         if (walk->next == NULL) {
+            walk->next = item;
+            break;
+         }
+         walk = walk->next;
+      }
+   }
+   int nval = DebugMemory_getBlockCount();
+   assert(nval == val + 1);
+   singleton->allocations++;
+   singleton->size++;
+   DebugMemory_assertSize();
+}
+
+void DebugMemory_registerDeallocation(void* data, char* file, int line) {
+   assert(singleton);
+   assert(singleton->first);
+   DebugMemoryItem* walk = singleton->first;
+   DebugMemoryItem* prev = NULL;
+   int val = DebugMemory_getBlockCount();
+   while (walk != NULL) {
+      if (walk->data == data) {
+         if (prev == NULL) {
+            singleton->first = walk->next;
+         } else {
+            prev->next = walk->next;
+         }
+         free(walk);
+         assert(DebugMemory_getBlockCount() == val - 1);
+         singleton->deallocations++;
+         singleton->size--;
+         DebugMemory_assertSize();
+         return;
+      }
+      DebugMemoryItem* tmp = walk;
+      walk = walk->next;
+      prev = tmp;
+   }
+   DebugMemory_report();
+   fprintf(stderr, "Couldn't find allocation for memory freed at %s:%d\n", file, line);
+   assert(false);
+}
+
+void DebugMemory_report() {
+   assert(singleton);
+   DebugMemoryItem* walk = singleton->first;
+   int i = 0;
+   while (walk != NULL) {
+      i++;
+      fprintf(stderr, "%p %s:%d\n", walk->data, walk->file, walk->line);
+      walk = walk->next;
+   }
+   fprintf(stderr, "Total:\n");
+   fprintf(stderr, "%d allocations\n", singleton->allocations);
+   fprintf(stderr, "%d deallocations\n", singleton->deallocations);
+   fprintf(stderr, "%d size\n", singleton->size);
+   fprintf(stderr, "%d non-freed blocks\n", i);
+   fclose(singleton->file);
+}

DebugMemory.h

+/* Do not edit this file. It was automatically genarated. */
+
+#ifndef HEADER_DebugMemory
+#define HEADER_DebugMemory
+
+#define _GNU_SOURCE
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdbool.h>
+
+#include <assert.h>
+
+
+#undef strdup
+#undef malloc
+#undef realloc
+#undef calloc
+#undef free
+
+typedef struct DebugMemoryItem_ DebugMemoryItem;
+
+struct DebugMemoryItem_ {
+   void* data;
+   char* file;
+   int line;
+   DebugMemoryItem* next;
+};
+
+typedef struct DebugMemory_ {
+   DebugMemoryItem* first;
+   int allocations;
+   int deallocations;
+   int size;
+   FILE* file;
+} DebugMemory;
+
+
+void DebugMemory_new();
+
+void* DebugMemory_malloc(int size, char* file, int line);
+
+void* DebugMemory_calloc(int a, int b, char* file, int line);
+
+void* DebugMemory_realloc(void* ptr, int size, char* file, int line);
+
+void* DebugMemory_strdup(char* str, char* file, int line);
+
+void DebugMemory_free(void* data, char* file, int line);
+
+void DebugMemory_assertSize();
+
+int DebugMemory_getBlockCount();
+
+void DebugMemory_registerAllocation(void* data, char* file, int line);
+
+void DebugMemory_registerDeallocation(void* data, char* file, int line);
+
+void DebugMemory_report();
+
+#endif

DisplayOptionsListBox.c

+
+#include "DisplayOptionsListBox.h"
+
+#include "ListBox.h"
+#include "CheckItem.h"
+#include "Settings.h"
+#include "ScreenManager.h"
+
+#include "debug.h"
+#include <assert.h>
+
+/*{
+
+typedef struct DisplayOptionsListBox_ {
+   ListBox super;
+
+   Settings* settings;
+   ScreenManager* scr;
+} DisplayOptionsListBox;
+
+}*/
+
+DisplayOptionsListBox* DisplayOptionsListBox_new(Settings* settings, ScreenManager* scr) {
+   DisplayOptionsListBox* this = (DisplayOptionsListBox*) malloc(sizeof(DisplayOptionsListBox));
+   ListBox* super = (ListBox*) this;
+   ListBox_init(super, 1, 1, 1, 1, CHECKITEM_CLASS, true);
+   ((Object*)this)->delete = DisplayOptionsListBox_delete;
+
+   this->settings = settings;
+   this->scr = scr;
+   super->eventHandler = DisplayOptionsListBox_EventHandler;
+
+   ListBox_setHeader(super, "Display options");
+   ListBox_add(super, (Object*) CheckItem_new(String_copy("Tree view"), &(settings->pl->treeView)));
+   ListBox_add(super, (Object*) CheckItem_new(String_copy("Shadow other users' processes"), &(settings->pl->shadowOtherUsers)));
+   ListBox_add(super, (Object*) CheckItem_new(String_copy("Hide kernel threads"), &(settings->pl->hideKernelThreads)));
+   ListBox_add(super, (Object*) CheckItem_new(String_copy("Hide userland threads"), &(settings->pl->hideUserlandThreads)));
+   ListBox_add(super, (Object*) CheckItem_new(String_copy("Highlight program \"basename\""), &(settings->pl->highlightBaseName)));
+   ListBox_add(super, (Object*) CheckItem_new(String_copy("Highlight megabytes in memory counters"), &(settings->pl->highlightMegabytes)));
+   ListBox_add(super, (Object*) CheckItem_new(String_copy("Leave a margin around header"), &(settings->header->margin)));
+   return this;
+}
+
+void DisplayOptionsListBox_delete(Object* object) {
+   ListBox* super = (ListBox*) object;
+   DisplayOptionsListBox* this = (DisplayOptionsListBox*) object;
+   ListBox_done(super);
+   free(this);
+}
+
+HandlerResult DisplayOptionsListBox_EventHandler(ListBox* super, int ch) {
+   DisplayOptionsListBox* this = (DisplayOptionsListBox*) super;
+   
+   HandlerResult result = IGNORED;
+   CheckItem* selected = (CheckItem*) ListBox_getSelected(super);
+
+   switch(ch) {
+   case 0x0a:
+   case 0x0d:
+   case KEY_ENTER:
+   case ' ':
+      *(selected->value) = ! *(selected->value);
+      result = HANDLED;
+   }
+
+   if (result == HANDLED) {
+      this->settings->changed = true;
+      Header* header = this->settings->header;
+      Header_calculateHeight(header);
+      Header_draw(header);
+      ScreenManager_resize(this->scr, this->scr->x1, header->height, this->scr->x2, this->scr->y2);
+   }
+   return result;
+}
+

DisplayOptionsListBox.h

+/* Do not edit this file. It was automatically genarated. */
+
+#ifndef HEADER_DisplayOptionsListBox
+#define HEADER_DisplayOptionsListBox
+
+
+#include "ListBox.h"
+#include "CheckItem.h"
+#include "Settings.h"
+#include "ScreenManager.h"
+
+#include "debug.h"
+#include <assert.h>
+
+
+typedef struct DisplayOptionsListBox_ {
+   ListBox super;
+
+   Settings* settings;
+   ScreenManager* scr;
+} DisplayOptionsListBox;
+
+
+DisplayOptionsListBox* DisplayOptionsListBox_new(Settings* settings, ScreenManager* scr);
+
+void DisplayOptionsListBox_delete(Object* object);
+
+HandlerResult DisplayOptionsListBox_EventHandler(ListBox* super, int ch);
+
+
+#endif

FunctionBar.c

+/*
+htop - FunctionBar.c
+(C) 2004,2005 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Object.h"
+#include "FunctionBar.h"
+#include "CRT.h"
+
+#include "debug.h"
+#include <assert.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <curses.h>
+
+/*{
+
+typedef struct FunctionBar_ {
+   Object super;
+   int size;
+   char** functions;
+   char** keys;
+   int* events;
+   bool staticData;
+} FunctionBar;
+
+extern char* FUNCTIONBAR_CLASS;
+
+}*/
+
+/* private property */
+char* FUNCTIONBAR_CLASS = "FunctionBar";
+
+/* private property */
+static char* FunctionBar_FKeys[10] = {"F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10"};
+
+/* private property */
+static char* FunctionBar_FLabels[10] = {"      ", "      ", "      ", "      ", "      ", "      ", "      ", "      ", "      ", "      "};
+
+/* private property */
+static int FunctionBar_FEvents[10] = {KEY_F(1), KEY_F(2), KEY_F(3), KEY_F(4), KEY_F(5), KEY_F(6), KEY_F(7), KEY_F(8), KEY_F(9), KEY_F(10)};
+
+FunctionBar* FunctionBar_new(int size, char** functions, char** keys, int* events) {
+   FunctionBar* this = malloc(sizeof(FunctionBar));
+   ((Object*) this)->class = FUNCTIONBAR_CLASS;
+   ((Object*) this)->delete = FunctionBar_delete;
+   this->functions = functions;
+   this->size = size;
+   if (keys && events) {
+      this->staticData = false; 
+      this->functions = malloc(sizeof(char*) * size);
+      this->keys = malloc(sizeof(char*) * size);
+      this->events = malloc(sizeof(int) * size);
+      for (int i = 0; i < size; i++) {
+         this->functions[i] = String_copy(functions[i]);
+         this->keys[i] = String_copy(keys[i]);
+         this->events[i] = events[i];
+      }
+   } else {
+      this->staticData = true;
+      this->functions = functions ? functions : FunctionBar_FLabels;
+      this->keys = FunctionBar_FKeys;
+      this->events = FunctionBar_FEvents;
+      assert((!functions) || this->size == 10);
+   }
+   return this;
+}
+
+void FunctionBar_delete(Object* cast) {
+   FunctionBar* this = (FunctionBar*) cast;
+   if (!this->staticData) {
+      for (int i = 0; i < this->size; i++) {
+         free(this->functions[i]);
+         free(this->keys[i]);
+      }
+      free(this->functions);
+      free(this->keys);
+      free(this->events);
+   }
+   free(this);
+}
+
+void FunctionBar_setLabel(FunctionBar* this, int event, char* text) {
+   assert(!this->staticData);
+   for (int i = 0; i < this->size; i++) {
+      if (this->events[i] == event) {
+         free(this->functions[i]);
+         this->functions[i] = String_copy(text);
+         break;
+      }
+   }
+}
+
+void FunctionBar_draw(FunctionBar* this, char* buffer) {
+   FunctionBar_drawAttr(this, buffer, CRT_colors[FUNCTION_BAR]);
+}
+
+void FunctionBar_drawAttr(FunctionBar* this, char* buffer, int attr) {
+   attrset(CRT_colors[FUNCTION_BAR]);
+   mvhline(LINES-1, 0, ' ', COLS);
+   int x = 0;
+   for (int i = 0; i < this->size; i++) {
+      attrset(CRT_colors[FUNCTION_KEY]);
+      mvaddstr(LINES-1, x, this->keys[i]);
+      x += strlen(this->keys[i]);
+      attrset(CRT_colors[FUNCTION_BAR]);
+      mvaddstr(LINES-1, x, this->functions[i]);
+      x += strlen(this->functions[i]);
+   }
+   if (buffer != NULL) {
+      attrset(attr);
+      mvaddstr(LINES-1, x, buffer);
+   }
+   attrset(CRT_colors[RESET_COLOR]);
+}
+
+int FunctionBar_synthesizeEvent(FunctionBar* this, int pos) {
+   int x = 0;
+   for (int i = 0; i < this->size; i++) {
+      x += strlen(this->keys[i]);
+      x += strlen(this->functions[i]);
+      if (pos < x) {
+         return this->events[i];
+      }
+   }
+   return ERR;
+}

FunctionBar.h

+/* Do not edit this file. It was automatically genarated. */
+
+#ifndef HEADER_FunctionBar
+#define HEADER_FunctionBar
+/*
+htop
+(C) 2004-2006 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Object.h"
+#include "CRT.h"
+
+#include "debug.h"
+#include <assert.h>
+
+#include <string.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <curses.h>
+
+
+typedef struct FunctionBar_ {
+   Object super;
+   int size;
+   char** functions;
+   char** keys;
+   int* events;
+   bool staticData;
+} FunctionBar;
+
+extern char* FUNCTIONBAR_CLASS;
+
+FunctionBar* FunctionBar_new(int size, char** functions, char** keys, int* events);
+
+void FunctionBar_delete(Object* this);
+
+void FunctionBar_draw(FunctionBar* this, char* buffer);
+
+void FunctionBar_setLabel(FunctionBar* this, int event, char* text);
+
+void FunctionBar_drawAttr(FunctionBar* this, char* buffer, int attr);
+
+int FunctionBar_synthesizeEvent(FunctionBar* this, int pos);
+
+#endif

Hashtable.c

+/*
+htop
+(C) 2004-2006 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Hashtable.h"
+
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "debug.h"
+
+/*{
+typedef struct Hashtable_ Hashtable;
+
+typedef void(*Hashtable_PairFunction)(int, void*, void*);
+typedef int(*Hashtable_HashAlgorithm)(Hashtable*, int);
+
+typedef struct HashtableItem {
+   int key;
+   void* value;
+   struct HashtableItem* next;
+} HashtableItem;
+
+struct Hashtable_ {
+   int size;
+   HashtableItem** buckets;
+   int items;
+   Hashtable_HashAlgorithm hashAlgorithm;
+   bool owner;
+};
+}*/
+
+HashtableItem* HashtableItem_new(int key, void* value) {
+   HashtableItem* this;
+   
+   this = (HashtableItem*) malloc(sizeof(HashtableItem));
+   this->key = key;
+   this->value = value;
+   this->next = NULL;
+   return this;
+}
+
+Hashtable* Hashtable_new(int size, bool owner) {
+   Hashtable* this;
+   
+   this = (Hashtable*) malloc(sizeof(Hashtable));
+   this->size = size;
+   this->buckets = (HashtableItem**) calloc(sizeof(HashtableItem*), size);
+   this->hashAlgorithm = Hashtable_hashAlgorithm;
+   this->owner = owner;
+   return this;
+}
+
+int Hashtable_hashAlgorithm(Hashtable* this, int key) {
+   return (key % this->size);
+}
+
+void Hashtable_delete(Hashtable* this) {
+   for (int i = 0; i < this->size; i++) {
+      HashtableItem* walk = this->buckets[i];
+      while (walk != NULL) {
+         if (this->owner)
+            free(walk->value);
+         HashtableItem* savedWalk = walk;
+         walk = savedWalk->next;
+         free(savedWalk);
+      }
+   }
+   free(this->buckets);
+   free(this);
+}
+
+inline int Hashtable_size(Hashtable* this) {
+   return this->items;
+}
+
+void Hashtable_put(Hashtable* this, int key, void* value) {
+   int index = this->hashAlgorithm(this, key);
+   HashtableItem** bucketPtr = &(this->buckets[index]);
+   while (true)
+      if (*bucketPtr == NULL) {
+         *bucketPtr = HashtableItem_new(key, value);
+         this->items++;
+         break;
+      } else if ((*bucketPtr)->key == key) {
+         if (this->owner)
+            free((*bucketPtr)->value);
+         (*bucketPtr)->value = value;
+         break;
+      } else
+         bucketPtr = &((*bucketPtr)->next);
+}
+
+void* Hashtable_remove(Hashtable* this, int key) {
+   int index = this->hashAlgorithm(this, key);
+   HashtableItem** bucketPtr = &(this->buckets[index]);
+   while (true)
+      if (*bucketPtr == NULL) {
+         return NULL;
+         break;
+      } else if ((*bucketPtr)->key == key) {
+         void* savedValue = (*bucketPtr)->value;
+         HashtableItem* savedNext = (*bucketPtr)->next;
+         free(*bucketPtr);
+         (*bucketPtr) = savedNext;
+         this->items--;
+         if (this->owner) {
+            free(savedValue);
+            return NULL;
+         } else {
+            return savedValue;
+         }
+      } else
+         bucketPtr = &((*bucketPtr)->next);
+}
+
+inline void* Hashtable_get(Hashtable* this, int key) {
+   int index = this->hashAlgorithm(this, key);
+   HashtableItem* bucketPtr = this->buckets[index];
+   while (true)
+      if (bucketPtr == NULL) {
+         return NULL;
+      } else if (bucketPtr->key == key) {
+         return bucketPtr->value;
+      } else
+         bucketPtr = bucketPtr->next;
+}
+
+void Hashtable_foreach(Hashtable* this, Hashtable_PairFunction f, void* userData) {
+   for (int i = 0; i < this->size; i++) {
+      HashtableItem* walk = this->buckets[i];
+      while (walk != NULL) {
+         f(walk->key, walk->value, userData);
+         walk = walk->next;
+      }
+   }
+}

Hashtable.h

+/* Do not edit this file. It was automatically genarated. */
+
+#ifndef HEADER_Hashtable
+#define HEADER_Hashtable
+/*
+htop
+(C) 2004-2006 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+
+#include <stdlib.h>
+#include <stdbool.h>
+
+#include "debug.h"
+
+typedef struct Hashtable_ Hashtable;
+
+typedef void(*Hashtable_PairFunction)(int, void*, void*);
+typedef int(*Hashtable_HashAlgorithm)(Hashtable*, int);
+
+typedef struct HashtableItem {
+   int key;
+   void* value;
+   struct HashtableItem* next;
+} HashtableItem;
+
+struct Hashtable_ {
+   int size;
+   HashtableItem** buckets;
+   int items;
+   Hashtable_HashAlgorithm hashAlgorithm;
+   bool owner;
+};
+
+HashtableItem* HashtableItem_new(int key, void* value);
+
+Hashtable* Hashtable_new(int size, bool owner);
+
+int Hashtable_hashAlgorithm(Hashtable* this, int key);
+
+void Hashtable_delete(Hashtable* this);
+
+inline int Hashtable_size(Hashtable* this);
+
+void Hashtable_put(Hashtable* this, int key, void* value);
+
+void* Hashtable_remove(Hashtable* this, int key);
+
+inline void* Hashtable_get(Hashtable* this, int key);
+
+void Hashtable_foreach(Hashtable* this, Hashtable_PairFunction f, void* userData);
+
+#endif

Header.c

+/*
+htop - Header.c
+(C) 2004,2005 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Header.h"
+#include "CPUMeter.h"
+#include "MemoryMeter.h"
+#include "SwapMeter.h"
+#include "LoadMeter.h"
+#include "LoadAverageMeter.h"
+#include "UptimeMeter.h"
+#include "ClockMeter.h"
+#include "TasksMeter.h"
+
+#include "debug.h"
+#include <assert.h>
+
+/*{
+
+typedef enum HeaderSide_ {
+   LEFT_HEADER,
+   RIGHT_HEADER
+} HeaderSide;
+
+typedef struct Header_ {
+   TypedVector* leftMeters;
+   TypedVector* rightMeters;
+   ProcessList* pl;
+   bool margin;
+   int height;
+   int pad;
+} Header;
+
+}*/
+
+#ifndef MAX
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#endif
+
+Header* Header_new(ProcessList* pl) {
+   Header* this = malloc(sizeof(Header));
+   this->leftMeters = TypedVector_new(METER_CLASS, true, DEFAULT_SIZE);
+   this->rightMeters = TypedVector_new(METER_CLASS, true, DEFAULT_SIZE);
+   this->margin = true;
+   this->pl = pl;
+   return this;
+}
+
+void Header_delete(Header* this) {
+   TypedVector_delete(this->leftMeters);
+   TypedVector_delete(this->rightMeters);
+   free(this);
+}
+
+void Header_createMeter(Header* this, char* name, HeaderSide side) {
+   TypedVector* meters = side == LEFT_HEADER
+                       ? this->leftMeters
+                       : this->rightMeters;
+
+   if (String_eq(name, "Swap")) {
+      TypedVector_add(meters, SwapMeter_new(this->pl));
+   } else if (String_eq(name, "Memory")) {
+      TypedVector_add(meters, MemoryMeter_new(this->pl));
+   } else if (String_eq(name, "Clock")) {
+      TypedVector_add(meters, ClockMeter_new(this->pl));
+   } else if (String_eq(name, "Load")) {
+      TypedVector_add(meters, LoadMeter_new(this->pl));
+   } else if (String_eq(name, "LoadAverage")) {
+      TypedVector_add(meters, LoadAverageMeter_new(this->pl));
+   } else if (String_eq(name, "Uptime")) {
+      TypedVector_add(meters, UptimeMeter_new(this->pl));
+   } else if (String_eq(name, "Tasks")) {
+      TypedVector_add(meters, TasksMeter_new(this->pl));
+   } else if (String_startsWith(name, "CPUAverage")) {
+      TypedVector_add(meters, CPUMeter_new(this->pl, 0));
+   } else if (String_startsWith(name, "CPU")) {
+      int num;
+      int ok = sscanf(name, "CPU(%d)", &num);
+      if (ok)
+         TypedVector_add(meters, CPUMeter_new(this->pl, num));
+   }
+}
+
+void Header_setMode(Header* this, int i, MeterMode mode, HeaderSide side) {
+   TypedVector* meters = side == LEFT_HEADER
+                       ? this->leftMeters
+                       : this->rightMeters;
+
+   Meter* meter = (Meter*) TypedVector_get(meters, i);
+   Meter_setMode(meter, mode);
+}
+
+Meter* Header_getMeter(Header* this, int i, HeaderSide side) {
+   TypedVector* meters = side == LEFT_HEADER
+                       ? this->leftMeters
+                       : this->rightMeters;
+
+   return (Meter*) TypedVector_get(meters, i);
+}
+
+int Header_size(Header* this, HeaderSide side) {
+   TypedVector* meters = side == LEFT_HEADER
+                       ? this->leftMeters
+                       : this->rightMeters;
+
+   return TypedVector_size(meters);
+}
+
+char* Header_readMeterName(Header* this, int i, HeaderSide side) {
+   TypedVector* meters = side == LEFT_HEADER
+                       ? this->leftMeters
+                       : this->rightMeters;
+
+   Meter* meter = (Meter*) TypedVector_get(meters, i);
+   return meter->name;
+}
+
+MeterMode Header_readMeterMode(Header* this, int i, HeaderSide side) {
+   TypedVector* meters = side == LEFT_HEADER
+                       ? this->leftMeters
+                       : this->rightMeters;
+
+   Meter* meter = (Meter*) TypedVector_get(meters, i);
+   return meter->mode;
+}
+
+void Header_defaultMeters(Header* this) {
+   for (int i = 1; i <= this->pl->processorCount; i++) {
+      TypedVector_add(this->leftMeters, CPUMeter_new(this->pl, i));
+   }
+   TypedVector_add(this->leftMeters, MemoryMeter_new(this->pl));
+   TypedVector_add(this->leftMeters, SwapMeter_new(this->pl));
+   TypedVector_add(this->rightMeters, TasksMeter_new(this->pl));
+   TypedVector_add(this->rightMeters, LoadAverageMeter_new(this->pl));
+   TypedVector_add(this->rightMeters, UptimeMeter_new(this->pl));
+}
+
+void Header_draw(Header* this) {
+   int height = this->height;
+   int pad = this->pad;
+   
+   attrset(CRT_colors[RESET_COLOR]);
+   for (int y = 0; y < height; y++) {
+      mvhline(y, 0, ' ', COLS);
+   }
+   for (int y = (pad / 2), i = 0; i < TypedVector_size(this->leftMeters); i++) {
+      Meter* meter = (Meter*) TypedVector_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 < TypedVector_size(this->rightMeters); i++) {
+      Meter* meter = (Meter*) TypedVector_get(this->rightMeters, i);
+      meter->draw(meter, COLS / 2 + pad, y, COLS / 2 - (pad * 2 - 1) - 1);
+      y += meter->h;
+   }
+}
+
+int Header_calculateHeight(Header* this) {
+   int pad = this->margin ? 2 : 0;
+   int leftHeight = pad;
+   int rightHeight = pad;
+
+   for (int i = 0; i < TypedVector_size(this->leftMeters); i++) {
+      Meter* meter = (Meter*) TypedVector_get(this->leftMeters, i);
+      leftHeight += meter->h;
+   }
+   for (int i = 0; i < TypedVector_size(this->rightMeters); i++) {
+      Meter* meter = (Meter*) TypedVector_get(this->rightMeters, i);
+      rightHeight += meter->h;
+   }
+   this->pad = pad;
+   this->height = MAX(leftHeight, rightHeight);
+   return this->height;
+}

Header.h

+/* Do not edit this file. It was automatically genarated. */
+
+#ifndef HEADER_Header
+#define HEADER_Header
+/*
+htop
+(C) 2004-2006 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "CPUMeter.h"
+#include "MemoryMeter.h"
+#include "SwapMeter.h"
+#include "LoadMeter.h"
+#include "LoadAverageMeter.h"
+#include "UptimeMeter.h"
+#include "ClockMeter.h"
+#include "TasksMeter.h"
+
+#include "debug.h"
+#include <assert.h>
+
+
+typedef enum HeaderSide_ {
+   LEFT_HEADER,
+   RIGHT_HEADER
+} HeaderSide;
+
+typedef struct Header_ {
+   TypedVector* leftMeters;
+   TypedVector* rightMeters;
+   ProcessList* pl;
+   bool margin;
+   int height;
+   int pad;
+} Header;
+
+
+Header* Header_new(ProcessList* pl);
+
+void Header_delete(Header* this);
+
+void Header_createMeter(Header* this, char* name, HeaderSide side);
+
+void Header_setMode(Header* this, int i, MeterMode mode, HeaderSide side);
+
+Meter* Header_getMeter(Header* this, int i, HeaderSide side);
+
+int Header_size(Header* this, HeaderSide side);
+
+char* Header_readMeterName(Header* this, int i, HeaderSide side);
+
+MeterMode Header_readMeterMode(Header* this, int i, HeaderSide side);
+
+void Header_defaultMeters(Header* this);
+
+void Header_draw(Header* this);
+
+int Header_calculateHeight(Header* this);
+
+#endif

INSTALL

+Copyright (C) 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software
+Foundation, Inc.
+
+   This file is free documentation; the Free Software Foundation gives
+unlimited permission to copy, distribute and modify it.
+
+Basic Installation
+==================
+
+   These are generic installation instructions.
+
+   The `configure' shell script attempts to guess correct values for
+various system-dependent variables used during compilation.  It uses
+those values to create a `Makefile' in each directory of the package.
+It may also create one or more `.h' files containing system-dependent
+definitions.  Finally, it creates a shell script `config.status' that
+you can run in the future to recreate the current configuration, and a
+file `config.log' containing compiler output (useful mainly for
+debugging `configure').
+
+   It can also use an optional file (typically called `config.cache'
+and enabled with `--cache-file=config.cache' or simply `-C') that saves
+the results of its tests to speed up reconfiguring.  (Caching is
+disabled by default to prevent problems with accidental use of stale
+cache files.)
+
+   If you need to do unusual things to compile the package, please try
+to figure out how `configure' could check whether to do them, and mail
+diffs or instructions to the address given in the `README' so they can
+be considered for the next release.  If you are using the cache, and at
+some point `config.cache' contains results you don't want to keep, you
+may remove or edit it.
+
+   The file `configure.ac' (or `configure.in') is used to create
+`configure' by a program called `autoconf'.  You only need
+`configure.ac' if you want to change it or regenerate `configure' using
+a newer version of `autoconf'.
+
+The simplest way to compile this package is:
+
+  1. `cd' to the directory containing the package's source code and type
+     `./configure' to configure the package for your system.  If you're
+     using `csh' on an old version of System V, you might need to type
+     `sh ./configure' instead to prevent `csh' from trying to execute
+     `configure' itself.
+
+     Running `configure' takes awhile.  While running, it prints some
+     messages telling which features it is checking for.
+
+  2. Type `make' to compile the package.
+
+  3. Optionally, type `make check' to run any self-tests that come with
+     the package.
+
+  4. Type `make install' to install the programs and any data files and
+     documentation.
+
+  5. You can remove the program binaries and object files from the
+     source code directory by typing `make clean'.  To also remove the
+     files that `configure' created (so you can compile the package for
+     a different kind of computer), type `make distclean'.  There is
+     also a `make maintainer-clean' target, but that is intended mainly
+     for the package's developers.  If you use it, you may have to get
+     all sorts of other programs in order to regenerate files that came
+     with the distribution.
+
+Compilers and Options
+=====================
+
+   Some systems require unusual options for compilation or linking that
+the `configure' script does not know about.  Run `./configure --help'
+for details on some of the pertinent environment variables.
+
+   You can give `configure' initial values for configuration parameters
+by setting variables in the command line or in the environment.  Here
+is an example:
+
+     ./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
+
+   *Note Defining Variables::, for more details.
+
+Compiling For Multiple Architectures
+====================================
+
+   You can compile the package for more than one kind of computer at the
+same time, by placing the object files for each architecture in their
+own directory.  To do this, you must use a version of `make' that
+supports the `VPATH' variable, such as GNU `make'.  `cd' to the
+directory where you want the object files and executables to go and run
+the `configure' script.  `configure' automatically checks for the
+source code in the directory that `configure' is in and in `..'.
+
+   If you have to use a `make' that does not support the `VPATH'
+variable, you have to compile the package for one architecture at a
+time in the source code directory.  After you have installed the
+package for one architecture, use `make distclean' before reconfiguring
+for another architecture.
+
+Installation Names
+==================
+
+   By default, `make install' will install the package's files in
+`/usr/local/bin', `/usr/local/man', etc.  You can specify an
+installation prefix other than `/usr/local' by giving `configure' the
+option `--prefix=PATH'.
+
+   You can specify separate installation prefixes for
+architecture-specific files and architecture-independent files.  If you
+give `configure' the option `--exec-prefix=PATH', the package will use
+PATH as the prefix for installing programs and libraries.
+Documentation and other data files will still use the regular prefix.
+
+   In addition, if you use an unusual directory layout you can give
+options like `--bindir=PATH' to specify different values for particular
+kinds of files.  Run `configure --help' for a list of the directories
+you can set and what kinds of files go in them.
+
+   If the package supports it, you can cause programs to be installed
+with an extra prefix or suffix on their names by giving `configure' the
+option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
+
+Optional Features
+=================
+
+   Some packages pay attention to `--enable-FEATURE' options to
+`configure', where FEATURE indicates an optional part of the package.
+They may also pay attention to `--with-PACKAGE' options, where PACKAGE
+is something like `gnu-as' or `x' (for the X Window System).  The
+`README' should mention any `--enable-' and `--with-' options that the
+package recognizes.
+
+   For packages that use the X Window System, `configure' can usually
+find the X include and library files automatically, but if it doesn't,
+you can use the `configure' options `--x-includes=DIR' and
+`--x-libraries=DIR' to specify their locations.
+
+Specifying the System Type
+==========================
+
+   There may be some features `configure' cannot figure out
+automatically, but needs to determine by the type of machine the package
+will run on.  Usually, assuming the package is built to be run on the
+_same_ architectures, `configure' can figure that out, but if it prints
+a message saying it cannot guess the machine type, give it the
+`--build=TYPE' option.  TYPE can either be a short name for the system
+type, such as `sun4', or a canonical name which has the form:
+
+     CPU-COMPANY-SYSTEM
+
+where SYSTEM can have one of these forms:
+
+     OS KERNEL-OS
+
+   See the file `config.sub' for the possible values of each field.  If
+`config.sub' isn't included in this package, then this package doesn't
+need to know the machine type.
+
+   If you are _building_ compiler tools for cross-compiling, you should
+use the `--target=TYPE' option to select the type of system they will
+produce code for.
+
+   If you want to _use_ a cross compiler, that generates code for a
+platform different from the build platform, you should specify the
+"host" platform (i.e., that on which the generated programs will
+eventually be run) with `--host=TYPE'.
+
+Sharing Defaults
+================
+
+   If you want to set default values for `configure' scripts to share,
+you can create a site shell script called `config.site' that gives
+default values for variables like `CC', `cache_file', and `prefix'.
+`configure' looks for `PREFIX/share/config.site' if it exists, then
+`PREFIX/etc/config.site' if it exists.  Or, you can set the
+`CONFIG_SITE' environment variable to the location of the site script.
+A warning: not all `configure' scripts look for a site script.
+
+Defining Variables
+==================
+
+   Variables not defined in a site shell script can be set in the
+environment passed to `configure'.  However, some packages may run
+configure again during the build, and the customized values of these
+variables may be lost.  In order to avoid this problem, you should set
+them in the `configure' command line, using `VAR=value'.  For example:
+
+     ./configure CC=/usr/local2/bin/gcc
+
+will cause the specified gcc to be used as the C compiler (unless it is
+overridden in the site shell script).
+
+`configure' Invocation
+======================
+
+   `configure' recognizes the following options to control how it
+operates.
+
+`--help'
+`-h'
+     Print a summary of the options to `configure', and exit.
+
+`--version'
+`-V'
+     Print the version of Autoconf used to generate the `configure'
+     script, and exit.
+
+`--cache-file=FILE'
+     Enable the cache: use and save the results of the tests in FILE,
+     traditionally `config.cache'.  FILE defaults to `/dev/null' to
+     disable caching.
+
+`--config-cache'
+`-C'
+     Alias for `--cache-file=config.cache'.
+
+`--quiet'
+`--silent'
+`-q'
+     Do not print messages saying which checks are being made.  To
+     suppress all normal output, redirect it to `/dev/null' (any error
+     messages will still be shown).
+
+`--srcdir=DIR'
+     Look for the package's source code in directory DIR.  Usually
+     `configure' can determine that directory automatically.
+
+`configure' also accepts some other, not widely useful, options.  Run
+`configure --help' for more details.
+

ListBox.c

+/*
+htop - ListBox.c
+(C) 2004,2005 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Object.h"
+#include "ListBox.h"
+#include "TypedVector.h"
+#include "CRT.h"
+#include "RichString.h"
+
+#include <math.h>
+#include <stdbool.h>
+
+#include "debug.h"
+#include <assert.h>
+
+#include <curses.h>
+//#link curses
+
+/*{
+
+typedef struct ListBox_ ListBox;
+
+typedef enum HandlerResult_ {
+   HANDLED,
+   IGNORED,
+   BREAK_LOOP
+} HandlerResult;
+
+typedef HandlerResult(*ListBox_EventHandler)(ListBox*, int);
+
+struct ListBox_ {
+   Object super;
+   int x, y, w, h;
+   WINDOW* window;
+   TypedVector* items;
+   int selected;
+   int scrollV, scrollH;
+   int oldSelected;
+   bool needsRedraw;
+   RichString header;
+   ListBox_EventHandler eventHandler;
+};
+
+extern char* LISTBOX_CLASS;
+
+}*/
+
+#ifndef MIN
+#define MIN(a,b) ((a)<(b)?(a):(b))
+#endif
+#ifndef MAX
+#define MAX(a,b) ((a)>(b)?(a):(b))
+#endif
+
+/* private property */
+char* LISTBOX_CLASS = "ListBox";
+
+ListBox* ListBox_new(int x, int y, int w, int h, char* type, bool owner) {
+   ListBox* this;
+   this = malloc(sizeof(ListBox));
+   ListBox_init(this, x, y, w, h, type, owner);
+   return this;
+}
+
+void ListBox_delete(Object* cast) {
+   ListBox* this = (ListBox*)cast;
+   ListBox_done(this);
+   free(this);
+}
+
+void ListBox_init(ListBox* this, int x, int y, int w, int h, char* type, bool owner) {
+   Object* super = (Object*) this;
+   super->class = LISTBOX_CLASS;
+   super->delete = ListBox_delete;
+   this->x = x;
+   this->y = y;
+   this->w = w;
+   this->h = h;
+   this->eventHandler = NULL;
+   this->items = TypedVector_new(type, owner, DEFAULT_SIZE);
+   this->scrollV = 0;
+   this->scrollH = 0;
+   this->selected = 0;
+   this->oldSelected = 0;
+   this->needsRedraw = true;
+   this->header.len = 0;
+}
+
+void ListBox_done(ListBox* this) {
+   assert (this != NULL);
+   RichString_delete(this->header);
+   TypedVector_delete(this->items);
+}
+
+inline void ListBox_setRichHeader(ListBox* this, RichString header) {
+   assert (this != NULL);
+
+   if (this->header.len > 0) {
+      RichString_delete(this->header);
+   }
+   this->header = header;
+   this->needsRedraw = true;
+}
+
+inline void ListBox_setHeader(ListBox* this, char* header) {
+   ListBox_setRichHeader(this, RichString_quickString(CRT_colors[PANEL_HEADER_FOCUS], header));
+}
+
+void ListBox_setEventHandler(ListBox* this, ListBox_EventHandler eh) {
+   this->eventHandler = eh;
+}
+
+void ListBox_move(ListBox* this, int x, int y) {
+   assert (this != NULL);
+
+   this->x = x;
+   this->y = y;
+   this->needsRedraw = true;
+}
+
+void ListBox_resize(ListBox* this, int w, int h) {
+   assert (this != NULL);
+
+   if (this->header.len > 0)
+      h--;
+   this->w = w;
+   this->h = h;
+   this->needsRedraw = true;
+}
+
+void ListBox_prune(ListBox* this) {
+   assert (this != NULL);
+
+   TypedVector_prune(this->items);
+   this->scrollV = 0;
+   this->selected = 0;
+   this->oldSelected = 0;
+   this->needsRedraw = true;
+}
+
+void ListBox_add(ListBox* this, Object* o) {
+   assert (this != NULL);
+
+   TypedVector_add(this->items, o);
+   this->needsRedraw = true;
+}
+
+void ListBox_insert(ListBox* this, int i, Object* o) {
+   assert (this != NULL);
+
+   TypedVector_insert(this->items, i, o);
+   this->needsRedraw = true;
+}
+
+void ListBox_set(ListBox* this, int i, Object* o) {
+   assert (this != NULL);
+
+   TypedVector_set(this->items, i, o);
+}
+
+Object* ListBox_get(ListBox* this, int i) {
+   assert (this != NULL);
+
+   return TypedVector_get(this->items, i);
+}
+
+Object* ListBox_remove(ListBox* this, int i) {
+   assert (this != NULL);
+
+   this->needsRedraw = true;
+   Object* removed = TypedVector_remove(this->items, i);
+   if (this->selected > 0 && this->selected >= TypedVector_size(this->items))
+      this->selected--;
+   return removed;
+}
+
+Object* ListBox_getSelected(ListBox* this) {
+   assert (this != NULL);
+
+   return TypedVector_get(this->items, this->selected);
+}
+
+void ListBox_moveSelectedUp(ListBox* this) {
+   assert (this != NULL);
+
+   TypedVector_moveUp(this->items, this->selected);
+   if (this->selected > 0)
+      this->selected--;
+}
+
+void ListBox_moveSelectedDown(ListBox* this) {
+   assert (this != NULL);
+
+   TypedVector_moveDown(this->items, this->selected);
+   if (this->selected + 1 < TypedVector_size(this->items))
+      this->selected++;
+}
+
+int ListBox_getSelectedIndex(ListBox* this) {
+   assert (this != NULL);
+
+   return this->selected;
+}
+
+int ListBox_getSize(ListBox* this) {
+   assert (this != NULL);
+
+   return TypedVector_size(this->items);
+}
+
+void ListBox_setSelected(ListBox* this, int selected) {
+   assert (this != NULL);
+
+   selected = MAX(0, MIN(TypedVector_size(this->items) - 1, selected));
+   this->selected = selected;
+}
+
+void ListBox_draw(ListBox* this, bool focus) {
+   assert (this != NULL);
+
+   int first, last;
+   int itemCount = TypedVector_size(this->items);
+   int scrollH = this->scrollH;
+   int y = this->y; int x = this->x;
+   first = this->scrollV;
+
+   if (this->h > itemCount) {
+      last = this->scrollV + itemCount;
+      move(y + last, x + 0);
+   } else {
+      last = MIN(itemCount, this->scrollV + this->h);
+   }
+   if (this->selected < first) {
+      first = this->selected;
+      this->scrollV = first;
+      this->needsRedraw = true;
+   }
+   if (this->selected >= last) {
+      last = MIN(itemCount, this->selected + 1);
+      first = MAX(0, last - this->h);
+      this->scrollV = first;
+      this->needsRedraw = true;
+   }
+   assert(first >= 0);
+   assert(last <= itemCount);
+
+   if (this->header.len > 0) {
+      int attr = focus
+               ? CRT_colors[PANEL_HEADER_FOCUS]
+               : CRT_colors[PANEL_HEADER_UNFOCUS];
+      attrset(attr);
+      mvhline(y, x, ' ', this->w);
+      if (scrollH < this->header.len) {
+         mvaddchnstr(y, x, this->header.chstr + scrollH,
+                     MIN(this->header.len - scrollH, this->w));
+      }
+      attrset(CRT_colors[RESET_COLOR]);
+      y++;
+   }
+   
+   int highlight = focus
+                 ? CRT_colors[PANEL_HIGHLIGHT_FOCUS]
+                 : CRT_colors[PANEL_HIGHLIGHT_UNFOCUS];
+
+   if (this->needsRedraw) {
+
+      for(int i = first, j = 0; j < this->h && i < last; i++, j++) {
+         Object* itemObj = TypedVector_get(this->items, i);
+         RichString itemRef = RichString_new();
+         itemObj->display(itemObj, &itemRef);
+         int amt = MIN(itemRef.len - scrollH, this->w);
+         if (i == this->selected) {
+            attrset(highlight);
+            RichString_setAttr(&itemRef, highlight);
+            mvhline(y + j, x+0, ' ', this->w);
+            if (amt > 0)
+               mvaddchnstr(y+j, x+0, itemRef.chstr + scrollH, amt);
+            attrset(CRT_colors[RESET_COLOR]);
+         } else {
+            mvhline(y+j, x+0, ' ', this->w);
+            if (amt > 0)
+               mvaddchnstr(y+j, x+0, itemRef.chstr + scrollH, amt);
+         }
+      }
+      for (int i = y + (last - first); i < y + this->h; i++)
+         mvhline(i, x+0, ' ', this->w);
+      this->needsRedraw = false;
+
+   } else {
+      Object* oldObj = TypedVector_get(this->items, this->oldSelected);
+      RichString oldRef = RichString_new();
+      oldObj->display(oldObj, &oldRef);
+      Object* newObj = TypedVector_get(this->items, this->selected);
+      RichString newRef = RichString_new();
+      newObj->display(newObj, &newRef);
+      mvhline(y+ this->oldSelected - this->scrollV, x+0, ' ', this->w);
+      if (scrollH < oldRef.len)
+         mvaddchnstr(y+ this->oldSelected - this->scrollV, x+0, oldRef.chstr + this->scrollH, MIN(oldRef.len - scrollH, this->w));
+      attrset(highlight);
+      mvhline(y+this->selected - this->scrollV, x+0, ' ', this->w);
+      RichString_setAttr(&newRef, highlight);
+      if (scrollH < newRef.len)
+         mvaddchnstr(y+this->selected - this->scrollV, x+0, newRef.chstr + this->scrollH, MIN(newRef.len - scrollH, this->w));
+      attrset(CRT_colors[RESET_COLOR]);
+   }
+   this->oldSelected = this->selected;
+   move(0, 0);
+}
+
+void ListBox_onKey(ListBox* this, int key) {
+   assert (this != NULL);
+   switch (key) {
+   case KEY_DOWN:
+      if (this->selected + 1 < TypedVector_size(this->items))
+         this->selected++;
+      break;
+   case KEY_UP:
+      if (this->selected > 0)
+         this->selected--;
+      break;
+   case KEY_LEFT:
+      if (this->scrollH > 0) {
+         this->scrollH -= 5;
+         this->needsRedraw = true;
+      }
+      break;
+   case KEY_RIGHT:
+      this->scrollH += 5;
+      this->needsRedraw = true;
+      break;
+   case KEY_PPAGE:
+      this->selected -= this->h;
+      if (this->selected < 0)
+         this->selected = 0;
+      break;
+   case KEY_NPAGE:
+      this->selected += this->h;
+      int size = TypedVector_size(this->items);
+      if (this->selected >= size)
+         this->selected = size - 1;
+      break;
+   case KEY_HOME:
+      this->selected = 0;
+      break;
+   case KEY_END:
+      this->selected = TypedVector_size(this->items) - 1;
+      break;
+   }
+}

ListBox.h

+/* Do not edit this file. It was automatically genarated. */
+
+#ifndef HEADER_ListBox
+#define HEADER_ListBox
+/*
+htop
+(C) 2004-2006 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Object.h"
+#include "TypedVector.h"
+#include "CRT.h"
+#include "RichString.h"
+
+#include <math.h>
+#include <sys/param.h>
+#include <stdbool.h>
+
+#include "debug.h"
+#include <assert.h>
+
+#include <curses.h>
+//#link curses
+
+
+typedef struct ListBox_ ListBox;
+
+typedef enum HandlerResult_ {
+   HANDLED,
+   IGNORED,
+   BREAK_LOOP
+} HandlerResult;
+
+typedef HandlerResult(*ListBox_EventHandler)(ListBox*, int);
+
+struct ListBox_ {
+   Object super;
+   int x, y, w, h;
+   WINDOW* window;
+   TypedVector* items;
+   int selected;
+   int scrollV, scrollH;
+   int oldSelected;
+   bool needsRedraw;
+   RichString header;
+   ListBox_EventHandler eventHandler;
+};
+
+extern char* LISTBOX_CLASS;
+
+
+
+ListBox* ListBox_new(int x, int y, int w, int h, char* type, bool owner);
+
+void ListBox_delete(Object* cast);
+
+void ListBox_init(ListBox* this, int x, int y, int w, int h, char* type, bool owner);
+
+void ListBox_done(ListBox* this);
+
+void ListBox_setEventHandler(ListBox* this, ListBox_EventHandler eh);
+
+void ListBox_setRichHeader(ListBox* this, RichString header);
+
+void ListBox_setHeader(ListBox* this, char* header);
+
+void ListBox_move(ListBox* this, int x, int y);
+
+void ListBox_resize(ListBox* this, int w, int h);
+
+void ListBox_prune(ListBox* this);
+
+void ListBox_add(ListBox* this, Object* o);
+
+void ListBox_insert(ListBox* this, int i, Object* o);
+
+void ListBox_set(ListBox* this, int i, Object* o);
+
+Object* ListBox_get(ListBox* this, int i);
+
+Object* ListBox_remove(ListBox* this, int i);
+
+Object* ListBox_getSelected(ListBox* this);
+
+void ListBox_moveSelectedUp(ListBox* this);
+
+void ListBox_moveSelectedDown(ListBox* this);
+
+int ListBox_getSelectedIndex(ListBox* this);
+
+int ListBox_getSize(ListBox* this);
+
+void ListBox_setSelected(ListBox* this, int selected);
+
+void ListBox_draw(ListBox* this, bool focus);
+
+void ListBox_onKey(ListBox* this, int key);
+
+#endif

ListItem.c

+/*
+htop - ListItem.c
+(C) 2004,2005 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "ListItem.h"
+#include "String.h"
+#include "Object.h"
+#include "RichString.h"
+#include <string.h>
+
+#include "debug.h"
+
+/*{
+
+typedef struct ListItem_ {
+   Object super;
+   char* value;
+   int key;
+} ListItem;
+
+extern char* LISTITEM_CLASS;
+}*/
+
+/* private property */
+char* LISTITEM_CLASS = "ListItem";
+
+ListItem* ListItem_new(char* value, int key) {
+   ListItem* this = malloc(sizeof(ListItem));
+   ((Object*)this)->class = LISTITEM_CLASS;
+   ((Object*)this)->display = ListItem_display;
+   ((Object*)this)->delete = ListItem_delete;
+   ((Object*)this)->compare = ListItem_compare;
+   this->value = String_copy(value);
+   this->key = key;
+   return this;
+}
+
+void ListItem_append(ListItem* this, char* text) {
+   char* buf = malloc(strlen(this->value) + strlen(text) + 1);
+   sprintf(buf, "%s%s", this->value, text);
+   free(this->value);
+   this->value = buf;
+}
+
+void ListItem_delete(Object* cast) {
+   ListItem* this = (ListItem*)cast;
+   free(this->value);
+   free(this);
+}
+
+void ListItem_display(Object* cast, RichString* out) {
+   ListItem* this = (ListItem*)cast;
+   assert (this != NULL);
+   int len = strlen(this->value)+1;
+   char buffer[len+1];
+   snprintf(buffer, len, "%s", this->value);
+   RichString_write(out, CRT_colors[DEFAULT_COLOR], buffer);
+}
+
+const char* ListItem_getRef(ListItem* this) {
+   return this->value;
+}
+
+int ListItem_compare(const Object* cast1, const Object* cast2) {
+   ListItem* obj1 = (ListItem*) cast1;
+   ListItem* obj2 = (ListItem*) cast2;
+   return strcmp(obj1->value, obj2->value);
+}
+

ListItem.h

+/* Do not edit this file. It was automatically genarated. */
+
+#ifndef HEADER_ListItem
+#define HEADER_ListItem
+/*
+htop
+(C) 2004-2006 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "String.h"
+#include "Object.h"
+#include "RichString.h"
+#include <string.h>
+
+#include "debug.h"
+
+typedef struct ListItem_ {
+   Object super;
+   char* value;
+   int key;
+} ListItem;
+
+extern char* LISTITEM_CLASS;
+
+ListItem* ListItem_new(char* value, int key);
+
+void ListItem_delete(Object* cast);
+
+void ListItem_display(Object* cast, RichString* out);
+
+void ListItem_append(ListItem* this, char* text);
+
+const char* ListItem_getRef(ListItem* this);
+
+int ListItem_compare(const Object*, const Object*);
+
+#endif

LoadAverageMeter.c

+/*
+htop
+(C) 2004-2006 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "LoadAverageMeter.h"
+#include "Meter.h"
+
+#include "ProcessList.h"
+
+#include <curses.h>
+
+#include "debug.h"
+
+/*{
+
+typedef struct LoadAverageMeter_ LoadAverageMeter;
+
+struct LoadAverageMeter_ {
+   Meter super;
+   ProcessList* pl;
+};
+
+}*/
+
+/* private property */
+void LoadAverageMeter_scan(double* one, double* five, double* fifteen);
+
+LoadAverageMeter* LoadAverageMeter_new() {
+   LoadAverageMeter* this = malloc(sizeof(LoadAverageMeter));
+   Meter_init((Meter*)this, String_copy("LoadAverage"), String_copy("Load average: "), 3);
+   ((Meter*)this)->attributes[0] = LOAD_AVERAGE_FIFTEEN;
+   ((Meter*)this)->attributes[1] = LOAD_AVERAGE_FIVE;
+   ((Meter*)this)->attributes[2] = LOAD_AVERAGE_ONE;
+   ((Object*)this)->display = LoadAverageMeter_display;
+   ((Meter*)this)->setValues = LoadAverageMeter_setValues;
+   Meter_setMode((Meter*)this, TEXT);
+   LoadAverageMeter_scan(&((Meter*)this)->values[0], &((Meter*)this)->values[1], &((Meter*)this)->values[2]);
+   ((Meter*)this)->total = 100.0;
+   return this;
+}
+
+/* private */
+void LoadAverageMeter_scan(double* one, double* five, double* fifteen) {
+   int activeProcs, totalProcs, lastProc;
+   FILE *fd = fopen(PROCDIR "/loadavg", "r");
+   int read = fscanf(fd, "%lf %lf %lf %d/%d %d", one, five, fifteen,
+      &activeProcs, &totalProcs, &lastProc);
+   (void) read;
+   assert(read == 6);
+   fclose(fd);
+}
+
+void LoadAverageMeter_setValues(Meter* cast) {
+   LoadAverageMeter_scan(&cast->values[2], &cast->values[1], &cast->values[0]);
+   snprintf(cast->displayBuffer.c, 25, "%.2f/%.2f/%.2f", cast->values[2], cast->values[1], cast->values[0]);
+}
+
+void LoadAverageMeter_display(Object* cast, RichString* out) {
+   Meter* this = (Meter*)cast;
+   char buffer[20];
+   RichString_prune(out);
+   sprintf(buffer, "%.2f ", this->values[2]);
+   RichString_append(out, CRT_colors[LOAD_AVERAGE_ONE], buffer);
+   sprintf(buffer, "%.2f ", this->values[1]);
+   RichString_append(out, CRT_colors[LOAD_AVERAGE_FIVE], buffer);
+   sprintf(buffer, "%.2f ", this->values[0]);
+   RichString_append(out, CRT_colors[LOAD_AVERAGE_FIFTEEN], buffer);
+}

LoadAverageMeter.h

+/* Do not edit this file. It was automatically genarated. */
+
+#ifndef HEADER_LoadAverageMeter
+#define HEADER_LoadAverageMeter
+/*
+htop
+(C) 2004-2006 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Meter.h"
+
+#include "ProcessList.h"
+
+#include <curses.h>
+
+#include "debug.h"
+
+
+typedef struct LoadAverageMeter_ LoadAverageMeter;
+
+struct LoadAverageMeter_ {
+   Meter super;
+   ProcessList* pl;
+};
+
+
+
+LoadAverageMeter* LoadAverageMeter_new();
+
+
+void LoadAverageMeter_setValues(Meter* cast);
+
+void LoadAverageMeter_display(Object* cast, RichString* out);
+
+#endif

LoadMeter.c

+/*
+htop
+(C) 2004-2006 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "LoadMeter.h"
+#include "Meter.h"
+
+#include "ProcessList.h"
+
+#include "debug.h"
+
+/*{
+
+typedef struct LoadMeter_ LoadMeter;
+
+struct LoadMeter_ {
+   Meter super;
+   ProcessList* pl;
+};
+
+}*/
+
+LoadMeter* LoadMeter_new() {
+   LoadMeter* this = malloc(sizeof(LoadMeter));
+   Meter_init((Meter*)this, String_copy("Load"), String_copy("Load: "), 1);
+   ((Meter*)this)->attributes[0] = LOAD;
+   ((Meter*)this)->setValues = LoadMeter_setValues;
+   ((Object*)this)->display = LoadMeter_display;
+   Meter_setMode((Meter*)this, GRAPH);
+   ((Meter*)this)->total = 1.0;
+   return this;
+}
+
+/* private */
+void LoadMeter_scan(double* one, double* five, double* fifteen) {
+   int activeProcs, totalProcs, lastProc;
+   FILE *fd = fopen(PROCDIR "/loadavg", "r");
+   int read = fscanf(fd, "%lf %lf %lf %d/%d %d", one, five, fifteen,
+      &activeProcs, &totalProcs, &lastProc);
+   (void) read;
+   assert(read == 6);
+   fclose(fd);
+}
+
+void LoadMeter_setValues(Meter* cast) {
+   double five, fifteen;
+   LoadMeter_scan(&cast->values[0], &five, &fifteen);
+   if (cast->values[0] > cast->total) {
+      cast->total = cast->values[0];
+   }
+   snprintf(cast->displayBuffer.c, 7, "%.2f", cast->values[0]);
+}
+
+void LoadMeter_display(Object* cast, RichString* out) {
+   LoadMeter* this = (LoadMeter*)cast;
+   char buffer[20];
+   RichString_prune(out);
+   sprintf(buffer, "%.2f ", ((Meter*)this)->values[0]);
+   RichString_append(out, CRT_colors[LOAD], buffer);
+}

LoadMeter.h

+/* Do not edit this file. It was automatically genarated. */
+
+#ifndef HEADER_LoadMeter
+#define HEADER_LoadMeter
+/*
+htop
+(C) 2004-2006 Hisham H. Muhammad
+Released under the GNU GPL, see the COPYING file
+in the source distribution for its full text.
+*/
+
+#include "Meter.h"
+
+#include "ProcessList.h"
+
+#include "debug.h"
+
+
+typedef struct LoadMeter_ LoadMeter;
+
+struct LoadMeter_ {
+   Meter super;
+   ProcessList* pl;
+};
+
+
+LoadMeter* LoadMeter_new();
+
+
+void LoadMeter_setValues(Meter* cast);
+
+void LoadMeter_display(Object* cast, RichString* out);
+
+#endif