Implemented pager for tasks and projects

src/pager.c

@@ -3,22 +3,93 @@
 #include <stdio.h>
 #include "pit.h"
 
-PPager pit_pager_initialize(ulong number_of_entries)
+#define for_each_entry(ppager, entry) for (entry = (uchar **)ppager->entries; (uchar *)*entry; entry++)
+
+PPager pit_pager_initialize(ulong type, ulong number_of_entries)
 {
-    return NULL;
+    PPager ppager = calloc(1, sizeof(Pager));
+
+    memset(ppager, 0, sizeof(Pager));
+    ppager->type = type;
+    ppager->entries = calloc(number_of_entries + 1, sizeof(uchar *));
+
+    return ppager;
 }
 
-uchar *pit_pager_add(PPager pp, uchar *entry)
+void pit_pager_print(PPager ppager, uchar *entry)
 {
-    return NULL;
+    char str[32];
+    uchar **pentry = (uchar **)ppager->entries + ppager->number_of_entries++;
+    *pentry = entry;
+
+    for_each_entry(ppager, pentry) {
+        switch(ppager->type) {
+        case PAGER_TASK:
+            sprintf(str, "%lu", ((PTask)*pentry)->id);
+            ppager->max.task.id = max(ppager->max.task.id, strlen(str));
+            ppager->max.task.name = max(ppager->max.task.name, strlen(((PTask)*pentry)->name));
+            ppager->max.task.status = max(ppager->max.task.status, strlen(((PTask)*pentry)->status));
+            ppager->max.task.priority = max(ppager->max.task.priority, strlen(((PTask)*pentry)->priority));
+            break;
+        case PAGER_PROJECT:
+            sprintf(str, "%lu", ((PProject)*pentry)->id);
+            ppager->max.project.id = max(ppager->max.project.id, strlen(str));
+            ppager->max.project.name = max(ppager->max.project.name, strlen(((PProject)*pentry)->name));
+            ppager->max.project.status = max(ppager->max.project.status, strlen(((PProject)*pentry)->status));
+            break;
+        default:
+            die("invalid pager type: %d\n", ppager->type);
+        }
+    }
 }
 
-void pit_pager_dump(PPager pp)
+void pit_pager_flush(PPager ppager)
 {
+    uchar **pentry;
+    char format[64];
 
+    switch(ppager->type) {
+    case PAGER_TASK:
+        sprintf(format, "%%c %%%dlu: %%-%ds %%-%ds %%-%ds (%%lu note%%s)\n",
+            ppager->max.task.id, ppager->max.task.status, ppager->max.task.priority, ppager->max.task.name
+        );
+        for_each_entry(ppager, pentry) {
+            printf(format, 
+                (((PTask)*pentry)->id == tasks->current ? '*' : ' '),
+                ((PTask)*pentry)->id,
+                ((PTask)*pentry)->status,
+                ((PTask)*pentry)->priority,
+                ((PTask)*pentry)->name,
+                ((PTask)*pentry)->number_of_notes,
+                (((PTask)*pentry)->number_of_notes != 1 ? "s" : "")
+            );
+        }
+        break;
+    case PAGER_PROJECT:
+        sprintf(format, "%%c %%%dlu: %%-%ds %%-%ds (%%lu open, %%lu closed task%%s)\n",
+            ppager->max.project.id, ppager->max.project.status, ppager->max.project.name
+        );
+        for_each_entry(ppager, pentry) {
+            printf(format,
+                (((PProject)*pentry)->id == projects->current ? '*' : ' '),
+                ((PProject)*pentry)->id,
+                ((PProject)*pentry)->status,
+                ((PProject)*pentry)->name,
+                ((PProject)*pentry)->number_of_open_tasks,
+                ((PProject)*pentry)->number_of_closed_tasks,
+                (projects->number_of_records != 1 ? "s" : "")
+            );
+        }
+        break;
+    default:
+        pit_pager_free(ppager);
+        die("invalid pager type: %d\n", ppager->type);
+    }
+    pit_pager_free(ppager);
 }
 
-void pit_pager_free(PPager pp, int deep)
+void pit_pager_free(PPager ppager)
 {
-    
+    free(ppager->entries);
+    free(ppager);
 }

src/pager.h

@@ -10,17 +10,26 @@
 typedef struct _Pager {
     ulong   type;
     ulong   number_of_entries;
-    int     max_id;
-    int     max_name;
-    int     max_status;
-    int     max_priority;
-    int     min_deadline;
     uchar   *entries;
+    union {
+        struct {
+            int id;
+            int name;
+            int status;
+        } project;
+        struct {
+            int id;
+            int name;
+            int status;
+            int priority;
+            int deadline;
+        } task;
+    } max;
 } Pager, *PPager;
 
-PPager pit_pager_initialize(ulong number_of_entries);
+PPager pit_pager_initialize(ulong type, ulong number_of_entries);
-uchar *pit_pager_add(PPager pp, uchar *entry);
+void   pit_pager_print(PPager ppager, uchar *entry);
-void   pit_pager_dump(PPager pp);
+void   pit_pager_flush(PPager ppager);
-void   pit_pager_free(PPager pp, int deep);
+void   pit_pager_free(PPager ppager);
 
 #endif

src/pit.h

@@ -4,12 +4,36 @@
 typedef unsigned int  uint;
 typedef unsigned long ulong;
 typedef unsigned char uchar;
+typedef int bool;
 
 #include <time.h>
 #include "object.h"
 #include "table.h"
 #include "pager.h"
 
+/* #defines */
+#ifndef FALSE
+#define FALSE (0)
+#endif
+
+#ifndef TRUE
+#define TRUE  (1)
+#endif
+
+#ifndef min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+#endif
+
+#ifndef max
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#endif
+
+#define for_each_activity(ptr) for (ptr = (PActivity)activities->slots; (ptr - (PActivity)activities->slots) < activities->number_of_records; ptr++)
+#define for_each_project(ptr)  for (ptr = (PProject)projects->slots; (ptr - (PProject)projects->slots) < projects->number_of_records; ptr++)
+#define for_each_note(ptr)     for (ptr = (PNote)notes->slots; (ptr - (PNote)notes->slots) < notes->number_of_records; ptr++)
+#define for_each_task(ptr)     for (ptr = (PTask)tasks->slots; (ptr - (PTask)tasks->slots) < tasks->number_of_records; ptr++)
+#define for_each_user(ptr)     for (ptr = (PUser)users->slots; (ptr - (PUser)users->slots) < users->number_of_records; ptr++)
+
 /* Externals. */
 extern PTable activities;
 extern PTable notes;
@@ -17,12 +41,6 @@ extern PTable projects;
 extern PTable tasks;
 extern PTable users;
 
-#define for_each_activity(ptr) for (ptr = (PActivity)tasks->slots; (ptr - (PActivity)tasks->slots) / sizeof(PActivity) < tasks->number_of_records; ptr++)
-#define for_each_note(ptr)     for (ptr = (PNote)tasks->slots;     (ptr - (PNote)tasks->slots)     / sizeof(PNote)     < tasks->number_of_records; ptr++)
-#define for_each_project(ptr)  for (ptr = (PProject)tasks->slots;  (ptr - (PProject)tasks->slots)  / sizeof(PProject)  < tasks->number_of_records; ptr++)
-#define for_each_task(ptr)     for (ptr = (PTask)tasks->slots;     (ptr - (PTask)tasks->slots)     / sizeof(PTask)     < tasks->number_of_records; ptr++)
-#define for_each_user(ptr)     for (ptr = (PUser)users->slots;     (ptr - (PUser)users->slots)     / sizeof(PUser)     < users->number_of_records; ptr++)
-
 /* args.c */
 int    pit_arg_is_option(char **arg);
 int    pit_arg_option(char **arg);

src/project.c

@@ -19,12 +19,15 @@ static int already_exist(char *name)
 static void list_projects()
 {
     PProject pp;
+    PPager   ppager;
 
     pit_db_load();
+    if (projects->number_of_records > 0) {
+        ppager = pit_pager_initialize(PAGER_PROJECT, projects->number_of_records);
         for_each_project(pp) {
-        printf("%c %lu: %s (%s, %lu open task%s)\n", (pp->id == projects->current ? '*' : ' '),
+            pit_pager_print(ppager, (uchar *)pp);
-        pp->id, pp->name, pp->status,
+        }
-        pp->number_of_open_tasks, (pp->number_of_open_tasks != 1 ? "s" : ""));
+        pit_pager_flush(ppager);
     }
 }
 

src/table.c

@@ -8,9 +8,8 @@
 ** Initialize the table by alloocating necessary memory chunks.
 */
 PTable pit_table_initialize(ulong record_size, ulong flags) {
-    PTable pt;
+    PTable pt = calloc(1, sizeof(Table));
 
-    pt = calloc(1, sizeof(Table));
     pt->flags             = flags;
     pt->record_size       = record_size;
     pt->number_of_slots   = TABLE_INCREMENT;

src/task.c

@@ -29,16 +29,21 @@ static void task_parse_options(char **arg, char **name, char **status, char **pr
 
 static void task_list(char *name, char *status, char *priority, time_t deadline)
 {
+    PProject pp;
+    PTask    pt;
+    PPager   ppager;
+
     pit_db_load();
-
+    if (tasks->number_of_records > 0) {
-    PTask pt = (PTask)tasks->slots;
+        pp = (PProject)pit_table_current(projects);
-    PProject pp = (PProject)pit_table_current(projects);
+        ppager = pit_pager_initialize(PAGER_TASK, tasks->number_of_records);
-
         for_each_task(pt) {
             if (pp && pt->project_id != pp->id) {
                 continue;
             }
-        printf("%c %lu: [%s] %s (%lu notes)\n", (pt->id == tasks->current ? '*' : ' '), pt->id, pt->status, pt->name, pt->number_of_notes);
+            pit_pager_print(ppager, (uchar *)pt);
+        }
+        pit_pager_flush(ppager);
     }
 }