// Compilation command: // - release: gcc main.c -Wall -Werror -pedantic -O2 -m64 -lncursesw -o ttt // - debug : gcc main.c -Wall -Werror -pedantic -g3 -m64 -lncursesw -o ttt -D DEBUG // Usage hints: // - To changes app data path change the environment variable HOME (USERPROFILE for windows users). #include #include #include #include #include #include #include #include #include #include #include #include #include #define VERSION "1.0" // Use only 3 chars (to fit layouts). #define MAX_TASK_NAME 58 // Maximum task name length (includes NUL). #define FIRST_DAY_OF_WEEK 1 // (0-6, Sunday = 0). #define NUM_WEEK_DAYS 7 // Just to avoid magic numbers. #define LOG_FILE_NAME "log.txt" #define APP_FOLDER_NAME ".task_time_tracker" #define DB_FILE_NAME "database.bin" #define AR_FILE_NAME "archive.csv" typedef struct { int64_t times[NUM_WEEK_DAYS]; char name[MAX_TASK_NAME]; } task_st; typedef struct { task_st *tasks; size_t count; size_t capacity; ptrdiff_t active_task; ptrdiff_t selected_task; int64_t modified_on; int64_t total_times[NUM_WEEK_DAYS]; } database_st; #define DB_FILE_SIGN_STR "TTT:B:01" const char DB_FILE_SIGN[] = DB_FILE_SIGN_STR; const size_t DB_FILE_SIGN_LENGTH = sizeof(DB_FILE_SIGN_STR)-1; const size_t SIZEOF_TASK_ST = sizeof(task_st); const size_t SIZEOF_DATABASE_ST = sizeof(database_st); const int64_t SECONDS_IN_MINUTE = (int64_t)60; const int64_t SECONDS_IN_HOUR = (int64_t)60*SECONDS_IN_MINUTE; const int64_t SECONDS_IN_DAY = (int64_t)24*SECONDS_IN_HOUR; const int64_t SECONDS_IN_YEAR = (int64_t)365*SECONDS_IN_DAY; database_st database = { .tasks = NULL }; database_st archive = { .tasks = NULL }; database_st *db = NULL; char *app_folder = NULL; char *db_file_path = NULL; char *ar_file_path = NULL; char *string_buffer = NULL; int size_x, size_y, pos_x, pos_y; // Checks if file is exists and is accessible. // Returns true when the file exists and is accessible. bool is_file_accessible(const char *path) { assert(path != NULL); FILE *file = fopen(path, "r+"); bool is_file_accessible = file != NULL; if (is_file_accessible) { fclose(file); } return is_file_accessible; } // Given an UTF8 encoded string, truncate it to length without breaking any UTF8 character. // The string should have capacity for at least length number of items. // The terminating null byte ('\0') is included in length. // The function returns the amount of items that got discarded counting from length. size_t truncate_string_utf8(char *string, size_t length) { // Check for special cases where no truncation is required. if (length == 0 || string[length-1] == '\0') { return 0; } // Search for a non-UTF8-sequence-item so we can truncate the string. size_t idx = length - 1; while(idx > 0 && ((string[idx] & 0xC0) == 0x80)) { idx--; } string[idx] = '\0'; return length - idx; } // Returns true when the string is empty or consists of white space characters. bool is_empty_string(char *string) { for(int idx = 0; string[idx] != '\0'; idx++) { switch(string[idx]) { case ' ': case '\t': case '\v': case '\f': case '\r': case '\n': break; default: return false; } } return true; } // Uses strchr to replace all instances of find by replace. // Returns string. char *replace_char(char *string, char find, char replace) { char *idx = string; while((idx = strchr(idx, find)) != NULL) { *idx = replace; idx++; } return string; } char *format_time(char* string, intmax_t time, int length) { int left_padding = (length - 5) / 2; int right_padding = length - 5 - left_padding; if (time > (intmax_t)9999 * SECONDS_IN_YEAR) { sprintf(string, "%*s ∞ %*s", left_padding, "", right_padding, ""); } else if (time > (intmax_t)9999 * SECONDS_IN_DAY) { double value = (double)time / (double)SECONDS_IN_YEAR; int decimals = time > 99 * SECONDS_IN_YEAR ? 0 : time > 9 * SECONDS_IN_YEAR ? 1 : 2; sprintf(string, "%*s%4.*fy%*s", left_padding, "", decimals, value, right_padding, ""); } else if (time >= (intmax_t)100 * SECONDS_IN_HOUR) { double value = (double)time / (double)SECONDS_IN_DAY; int decimals = time > 99 * SECONDS_IN_DAY ? 0 : time > 9 * SECONDS_IN_DAY ? 1 : 2; sprintf(string, "%*s%4.*fd%*s", left_padding, "", decimals, value, right_padding, ""); } else if (time >= SECONDS_IN_MINUTE) { intmax_t hours = (double)time / (double)SECONDS_IN_HOUR; intmax_t minutes = (time - (hours * SECONDS_IN_HOUR) ) / SECONDS_IN_MINUTE; sprintf(string, "%*s%02jd:%02jd%*s", left_padding, "", hours, minutes, right_padding, ""); } else if (time > 0) { sprintf(string, "%*s%3jds %*s", left_padding, "", time, right_padding, ""); } else if (time == 0) { sprintf(string, "%*s 0 %*s", left_padding, "", right_padding, ""); } else { sprintf(string, "%*s - %*s", left_padding, "", right_padding, ""); } return string; } int64_t add_int64(int64_t x, int64_t y) { if (y > 0 && x > INT64_MAX - y) return INT64_MAX; if (y < 0 && x < INT64_MIN - y) return INT64_MIN; return x + y; } int64_t sub_int64(int64_t x, int64_t y) { if (y < 0 && x > INT64_MAX + y) return INT64_MAX; if (y > 0 && x < INT64_MIN + y) return INT64_MIN; return x - y; } // Returns active task or NULL if none applies. task_st *get_active_task(database_st *db) { assert(db != NULL); task_st *task = NULL; if (db->active_task >= 0) { task = db->tasks + db->active_task; } return task; } // Returns selected task or NULL if none applies. task_st *get_selected_task(database_st *db) { assert(db != NULL); task_st *task = NULL; if (db->selected_task >= 0) { task = db->tasks + db->selected_task; } return task; } // Creates new task returned in the pointer. If necessary, expands database capacity. // Returns success. bool create_task(database_st *db, task_st **task) { assert(db != NULL); if (db->count == PTRDIFF_MAX) { fprintf(stderr, "Database reached maximum capacity.\n"); return false; } // If necessary, expand database capacity. size_t current_capacity = db->capacity; if((db->count + 1) > current_capacity) { size_t new_capacity = current_capacity == 0 ? 2 : current_capacity > PTRDIFF_MAX >> 1 ? PTRDIFF_MAX : current_capacity << 1; task_st *new_tasks = realloc(db->tasks, new_capacity * SIZEOF_TASK_ST); if (new_tasks == NULL) { fprintf(stderr, "Failed to expand database.\n"); return false; } db->capacity = new_capacity; db->tasks = new_tasks; } // Prepare new task. *task = &db->tasks[db->count]; memset(*task, 0, SIZEOF_TASK_ST); db->count++; // Adjust selected task. if (db->selected_task < 0) { db->selected_task = db->count-1; } return true; } // Adds the given task to the database using (using create_task and memcpy). // Returns success. bool add_task(database_st *db, task_st *task) { assert(db != NULL); assert(task != NULL); task_st *new_task; if (create_task(db, &new_task) == false) { return false; } memcpy(new_task, task, SIZEOF_TASK_ST); // Add task timer values to total timers. for (int idx = 0; idx < NUM_WEEK_DAYS; idx++) { // db->total_times[idx] += task->times[idx]; TODO db->total_times[idx] = add_int64(db->total_times[idx], task->times[idx]); } return true; } // Deletes the task provided in the pointer. If possible, shrinks the database capacity. // Returns success. bool delete_task(database_st *db, task_st *task) { assert(db != NULL); assert(task != NULL); assert(task >= db->tasks && task < &db->tasks[db->count]); // Remove task timer values from total timers. for (int idx = 0; idx < NUM_WEEK_DAYS; idx++) { // db->total_times[idx] -= task->times[idx]; TODO db->total_times[idx] = sub_int64(db->total_times[idx], task->times[idx]); } // Move tasks after the index position to their new positions. ptrdiff_t index = task - db->tasks; memmove(task, task + 1, (db->count - index - 1) * SIZEOF_TASK_ST); db->count--; // Adjust selected task. if (db->selected_task >= db->count) { // TODO Can we compare ptrdiff_t with size_t? db->selected_task--; } // Adjust active task. if (db->active_task > index) { db->active_task--; } else if (db->active_task == index) { db->active_task = -1; } // If possible, shrink database capacity. size_t current_capacity = db->capacity; if (db->count <= (current_capacity >> 2)) { size_t new_capacity = current_capacity >> 1; task_st *new_tasks = realloc(db->tasks, new_capacity * SIZEOF_TASK_ST); if (new_tasks == NULL && new_capacity > 0) { fprintf(stderr, "Failed to shrink database.\n"); return false; } db->capacity = new_capacity; db->tasks = new_tasks; } return true; } // Deletes the task provided in the pointer. If possible, shrinks the database capacity. // Returns success. bool move_task(database_st *db, task_st *task, size_t target) { assert(db != NULL); assert(task != NULL); assert(task >= db->tasks && task < &db->tasks[db->count]); assert(target >= 0 && target < db->count); // Move tasks after the index position to their new positions. ptrdiff_t index = task - db->tasks; task_st *target_task = &db->tasks[target]; ptrdiff_t target_index = target_task - db->tasks; if (target_task == task) { return true; } task_st temp_task; memcpy(&temp_task, task, SIZEOF_TASK_ST); // TODO Simplify code if (target_index > index) { memmove(task, task + 1, (target_index - index) * SIZEOF_TASK_ST); } else { memmove(target_task + 1, target_task, (index - target_index) * SIZEOF_TASK_ST); } memcpy(target_task, &temp_task, SIZEOF_TASK_ST); if (db->active_task == index) { db->active_task = target_index; } else if (db->active_task > index && db->active_task <= target_index) { db->active_task--; } else if (db->active_task >= target_index && db->active_task < index) { db->active_task++; } db->selected_task = target_index; return true; // TODO } // Resets database to the initial state and deallocates all memory taken by tasks. void reset_database(database_st *db) { assert(db != NULL); free(db->tasks); memset(db, 0, SIZEOF_DATABASE_ST); db->active_task = -1; db->selected_task = -1; } // Stores data from database into binary file. // Returns success. bool store_database(const database_st *db, const char *path) { assert(db != NULL); assert(path != NULL); // Open file. FILE *file = fopen(path, "wb"); if (file == NULL) { fprintf(stderr, "Failed to open file '%s' while storing database: %s.\n", path, strerror(errno)); return false; } fwrite(DB_FILE_SIGN, sizeof(char), DB_FILE_SIGN_LENGTH, file); fwrite(db, SIZEOF_DATABASE_ST, 1, file); fwrite(db->tasks, SIZEOF_TASK_ST, db->count, file); fclose(file); return true; } // Loads data from binary file into database. // Returns success. bool load_database(database_st *db, const char *path) { assert(db != NULL); assert(path != NULL); // Open file. FILE *file = fopen(path, "rb"); if (file == NULL) { fprintf(stderr, "Failed to open file '%s' while loading database: %s.\n", path, strerror(errno)); return false; } // Validate file signature. char file_signature[DB_FILE_SIGN_LENGTH]; fread(&file_signature, sizeof(char), DB_FILE_SIGN_LENGTH, file); if (strncmp(file_signature, DB_FILE_SIGN, DB_FILE_SIGN_LENGTH) != 0) { fprintf(stderr, "Invalid file signature.\n"); fclose(file); return false; } // Read database structure. fread(db, SIZEOF_DATABASE_ST, 1, file); // Restore database capacity. db->tasks = calloc(db->capacity, SIZEOF_TASK_ST); // Read database entries. fread(db->tasks, SIZEOF_TASK_ST, db->count, file); // Make sure we are reading all the file. assert(fgetc(file) == EOF); fclose(file); return true; } // Exports data into CSV file. // Returns success. bool export_to_csv(const database_st *db, const char *path) { assert(db != NULL); assert(path != NULL); FILE *file = fopen(path, "w"); if (file == NULL) { fprintf(stderr, "Failed to open file '%s' while exporting to CSV: %s.\n", path, strerror(errno)); return false; } fprintf(file, "%s,%s,%s,%s,%s,%s,%s,%s\n", "task", "sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday" ); char name[MAX_TASK_NAME]; task_st *limit = db->tasks + db->count; for (task_st *task = db->tasks; task < limit; task++) { memcpy(name, task->name, MAX_TASK_NAME); replace_char(name, ',', ' '); fprintf(file, "%s,%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 "\n", name, task->times[0], task->times[1], task->times[2], task->times[3], task->times[4], task->times[5], task->times[6] ); } fclose(file); return true; } // Imports CSV file into database. // Returns success. bool import_from_csv(database_st *db, const char *path) { assert(db != NULL); assert(path != NULL); FILE *file = fopen(path, "r"); if (file == NULL) { fprintf(stderr, "Failed to open file '%s' while importing from CSV: %s.\n", path, strerror(errno)); return false; } // Skip header line. fscanf(file, "%*[^\n]\n"); // Parse CSV file. char *csv_buffer = NULL; size_t csv_buffer_size = 0; while(getline(&csv_buffer, &csv_buffer_size, file) != -1) { // Check if reached EOF. // Find task name string limits. char *name_delimiter = strchr(csv_buffer, ','); if (name_delimiter == NULL) { continue; } size_t name_length = (name_delimiter - csv_buffer) + 1; if (name_length > MAX_TASK_NAME) { name_length = MAX_TASK_NAME; } // Prepare new task. task_st *task; create_task(db, &task); // Import task name. memcpy(task->name, csv_buffer, name_length); truncate_string_utf8(task->name, name_length); // Parse task times. if(sscanf(name_delimiter+1, "%" SCNd64 ",%" SCNd64 ",%" SCNd64 ",%" SCNd64 ",%" SCNd64 ",%" SCNd64 ",%" SCNd64, &task->times[0], &task->times[1], &task->times[2], &task->times[3], &task->times[4], &task->times[5], &task->times[6] ) != NUM_WEEK_DAYS) { replace_char(csv_buffer, '\n', ' '); fprintf(stderr, "Discarding invalid line '%s' and continuing.\n", csv_buffer); delete_task(db, task); continue; } // Add task timer values to total timers. for (int idx = 0; idx < NUM_WEEK_DAYS; idx++) { // db->total_times[idx] += task->times[idx]; TODO db->total_times[idx] = add_int64(db->total_times[idx], task->times[idx]); } } fclose(file); free(csv_buffer); return true; } bool append_to_csv(task_st *task, const char *path) { assert(task != NULL); assert(path != NULL); FILE *file = fopen(path, "a+"); if (file == NULL) { fprintf(stderr, "Failed to open file '%s' while appending to CSV: %s.\n", path, strerror(errno)); return false; } char last_char; fseek(file, -1, SEEK_END); fread(&last_char, sizeof(char), 1, file); if (last_char != '\n') { fprintf(file, "\n"); } char name[MAX_TASK_NAME]; memcpy(name, task->name, MAX_TASK_NAME); replace_char(name, ',', ' '); fprintf(file, "%s,%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 "\n", name, task->times[0], task->times[1], task->times[2], task->times[3], task->times[4], task->times[5], task->times[6] ); fclose(file); return true; } void update_timers(database_st *db) { // Get current UTC time. time_t stop_time = time(NULL); // Get last modified on UTC time. time_t start_time = db->modified_on; if (db->active_task < 0) { return; } task_st *active_task = db->tasks + db->active_task; uint8_t start_week_day; while (start_time < stop_time) { start_week_day = localtime(&start_time)->tm_wday; // Get next day in local time. struct tm *start_of_day_tm = localtime(&start_time); start_of_day_tm->tm_sec = 0; start_of_day_tm->tm_min = 0; start_of_day_tm->tm_hour = 0; time_t start_of_day = mktime(start_of_day_tm); time_t next_day = start_of_day + SECONDS_IN_DAY; time_t next_start = next_day < stop_time ? next_day : stop_time; time_t elapsed_time = next_start - start_time; active_task->times[start_week_day] += elapsed_time; db->total_times[start_week_day] += elapsed_time; start_time = next_start; } db->modified_on = stop_time; } void update_total_timers(database_st *db) { int64_t *d0 = &db->total_times[0]; int64_t *d1 = &db->total_times[1]; int64_t *d2 = &db->total_times[2]; int64_t *d3 = &db->total_times[3]; int64_t *d4 = &db->total_times[4]; int64_t *d5 = &db->total_times[5]; int64_t *d6 = &db->total_times[6]; memset(db->total_times, 0, NUM_WEEK_DAYS * sizeof(int64_t)); for (size_t idx = 0; idx < db->count; idx++) { int64_t *times = db->tasks[idx].times; *d0 = add_int64(*d0, times[0]); *d1 = add_int64(*d1, times[1]); *d2 = add_int64(*d2, times[2]); *d3 = add_int64(*d3, times[3]); *d4 = add_int64(*d4, times[4]); *d5 = add_int64(*d5, times[5]); *d6 = add_int64(*d6, times[6]); } } #define INPUT_TIMEOUT_MS 1000 #define INPUT_AWAIT_INF -1 #define NUM_HEADER_ROWS 1 #define NUM_FOOTER_ROWS 1 #define NUM_TABLE_ROWS (size_y - NUM_HEADER_ROWS - NUM_FOOTER_ROWS) #define NUM_COLUMNS 9 #define L_TITLE_IDX 0 #define L_DAYS_IDX 1 #define L_TOTAL_IDX 8 #define THEME_A 1 #define THEME_B 2 #define THEME_C 3 #define THEME_D 4 #define THEME_E 5 typedef enum { L_NORMAL, L_COMPACT, NUM_LAYOUTS, } layouts_et; typedef struct { char *header; int width; int alignment_offset; char alignment; } column_st; typedef struct { column_st columns[NUM_COLUMNS]; char *archive_title; } layout_st; layout_st layouts[NUM_LAYOUTS]; void initialize_tui() { // Normal layout. layouts[L_NORMAL] = (layout_st) { .archive_title = " Archive ", .columns = { { .header = " Task Time Tracker v" VERSION " ", .width = -1, .alignment = 'L' }, { .header = " Sun ", .width = 7, .alignment = 'C' }, { .header = " Mon ", .width = 7, .alignment = 'C' }, { .header = " Tue ", .width = 7, .alignment = 'C' }, { .header = " Wed ", .width = 7, .alignment = 'C' }, { .header = " Thu ", .width = 7, .alignment = 'C' }, { .header = " Fri ", .width = 7, .alignment = 'C' }, { .header = " Sat ", .width = 7, .alignment = 'C' }, { .header = " Total ", .width = 9, .alignment = 'C' }, } }; // Compact layout. layouts[L_COMPACT] = (layout_st) { .archive_title = " Archive ", .columns = { { .header = " TTT v" VERSION " ", .width = -1, .alignment = 'L' }, { .header = " S ", .width = 5, .alignment = 'C' }, { .header = " M ", .width = 5, .alignment = 'C' }, { .header = " T ", .width = 5, .alignment = 'C' }, { .header = " W ", .width = 5, .alignment = 'C' }, { .header = " T ", .width = 5, .alignment = 'C' }, { .header = " F ", .width = 5, .alignment = 'C' }, { .header = " S ", .width = 5, .alignment = 'C' }, { .header = " # ", .width = 5, .alignment = 'C' }, } }; // Calculate alignment_offsets. for(layout_st *layout = layouts; layout < layouts + NUM_LAYOUTS; layout++) { for (column_st *col = layout->columns; col < layout->columns + NUM_COLUMNS; col++) { int offset; switch(col->alignment) { default: case 'L': offset = 0; break; case 'C': offset = ((col->width - strlen(col->header)) / 2); break; case 'R': offset = (col->width - strlen(col->header)); break; } col->alignment_offset = offset; } } setlocale(LC_ALL, "C.UTF-8"); // Sets locale for C library functions; Allows usage of UTF-8. initscr(); // Start curses mode. cbreak(); // Line buffering disabled; pass on everty thing to me. keypad(stdscr, TRUE); // I need that nifty F1. curs_set(0); // Set cursor invisible. noecho(); // Disable echoing input characters. // Initialize pairs of colors. start_color(); init_pair(THEME_A, COLOR_BLUE, COLOR_BLACK); init_pair(THEME_B, COLOR_BLACK, COLOR_CYAN); init_pair(THEME_C, COLOR_WHITE, COLOR_BLUE); init_pair(THEME_D, COLOR_CYAN, COLOR_BLACK); init_pair(THEME_E, COLOR_BLUE, COLOR_BLACK); } void recalculate_tui() { // Recalculate first column width: expands to fill the remaining space dynamically. for (layout_st *layout = layouts; layout <= &layouts[NUM_LAYOUTS-1]; layout++) { layout->columns[0].width = size_x - (NUM_COLUMNS - 1) - 2; for (int idx = 1; idx < NUM_COLUMNS; idx++) { layout->columns[0].width -= layout->columns[idx].width; } } } void draw_tui(database_st *db, layout_st *layout) { const static int adjust_first_day_of_week[] = { (0 + FIRST_DAY_OF_WEEK) % NUM_WEEK_DAYS, (1 + FIRST_DAY_OF_WEEK) % NUM_WEEK_DAYS, (2 + FIRST_DAY_OF_WEEK) % NUM_WEEK_DAYS, (3 + FIRST_DAY_OF_WEEK) % NUM_WEEK_DAYS, (4 + FIRST_DAY_OF_WEEK) % NUM_WEEK_DAYS, (5 + FIRST_DAY_OF_WEEK) % NUM_WEEK_DAYS, (6 + FIRST_DAY_OF_WEEK) % NUM_WEEK_DAYS, }; int x, y; column_st *col; // Get context information. task_st *active_task = get_active_task(db); task_st *selected_task = get_selected_task(db); time_t now_utc = time(NULL); int now_week_day = localtime(&now_utc)->tm_wday; // Reset theme and clear screen. attrset(A_NORMAL); erase(); // Draw outer border. box(stdscr, 0, 0); // Draw table grids. y = 0; x = 0; for (int idx = 0; idx < NUM_COLUMNS - 1; idx++) { x += 1 + layout->columns[idx].width; mvaddch(y, x, ACS_TTEE); for (y = 1; y < size_y - 1; y++) { mvaddch(y, x, ACS_VLINE); } mvaddch(size_y - 1, x, ACS_BTEE); } /////////////////////////////////////////////////////////////////////////// // Draw headers. y = 0; x = 0; // Headers : title x++; col = &layout->columns[L_TITLE_IDX]; mvaddstr(y, x + col->alignment_offset, (db == &archive ? layout->archive_title : col->header)); x += col->width; // Headers : days for (int raw_idx = 0; raw_idx < NUM_WEEK_DAYS; raw_idx++) { int idx = adjust_first_day_of_week[raw_idx]; x++; // Apply theme. if (idx == now_week_day && active_task != NULL) { attron(COLOR_PAIR(THEME_E) | A_BOLD); } else if(idx == now_week_day) { attron(COLOR_PAIR(THEME_D) | A_BOLD); } col = &layout->columns[L_DAYS_IDX + idx]; mvaddstr(y, x + col->alignment_offset, col->header); x += col->width; // Reset theme. attrset(A_NORMAL); } // Headers : total x++; col = &layout->columns[L_TOTAL_IDX]; mvaddstr(y, x + col->alignment_offset, col->header); /////////////////////////////////////////////////////////////////////////// // Draw tasks. uint64_t total_time = 0; int column_width; // TODO This is some sort of pagination to allow scrolling through the tasks. // TODO How does this behaves when no task is selected? y = 0; size_t available_rows = NUM_TABLE_ROWS; size_t idx_start = (db->selected_task / available_rows) * available_rows; size_t idx_stop = idx_start + (available_rows > db->count - idx_start ? db->count - idx_start : available_rows); for (size_t idx = idx_start; idx < idx_stop; idx++) { task_st *task = &db->tasks[idx]; y++; x = 0; // Apply theme. if (task == active_task && task == selected_task) { attron(COLOR_PAIR(THEME_C) | A_BOLD); } else if (task == selected_task) { attron(COLOR_PAIR(THEME_B)); } else if(task == active_task) { attron(COLOR_PAIR(THEME_A) | A_BOLD); } // Task title. x++; column_width = layout->columns[L_TITLE_IDX].width; sprintf(string_buffer, "%*s", column_width, ""); mvaddnstr(y, x, string_buffer, column_width); mvaddnstr(y, x, task->name, column_width); x += column_width; // Task times. total_time = 0; for (int idx = 0; idx < NUM_WEEK_DAYS; idx++) { x++; int day_idx = (idx + FIRST_DAY_OF_WEEK) % NUM_WEEK_DAYS; column_width = layout->columns[L_DAYS_IDX + day_idx].width; int64_t task_stime = task->times[day_idx]; total_time = add_int64(total_time, task_stime); format_time(string_buffer, task_stime, column_width); mvaddstr(y, x, string_buffer); x += column_width; } // Task total. x++; format_time(string_buffer, total_time, layout->columns[L_TOTAL_IDX].width); mvaddstr(y, x, string_buffer); // Reset theme. attrset(A_NORMAL); } /////////////////////////////////////////////////////////////////////////// // Draw selected/total tasks. sprintf(string_buffer, " %td/%zd ", db->selected_task+1, db->count); if (strlen(string_buffer) > layout->columns[L_TITLE_IDX].width) { sprintf(string_buffer, "%td", db->selected_task+1); } mvaddstr(size_y-1, 1, string_buffer); /////////////////////////////////////////////////////////////////////////// // Draw daily totals. y = size_y-1; x = 0 + 1 + layout->columns[L_TITLE_IDX].width; total_time = 0; for (int raw_idx = 0; raw_idx < NUM_WEEK_DAYS; raw_idx++) { int idx = adjust_first_day_of_week[raw_idx]; int64_t daily_total = db->total_times[idx]; x++; column_width = layout->columns[L_DAYS_IDX + idx].width; total_time = add_int64(total_time, daily_total); format_time(string_buffer, daily_total, column_width); // Apply theme. if (idx == now_week_day && active_task != NULL) { attron(COLOR_PAIR(THEME_E) | A_BOLD); } else if(idx == now_week_day) { attron(COLOR_PAIR(THEME_D) | A_BOLD); } mvaddstr(y, x, string_buffer); x += column_width; // Reset theme. attrset(A_NORMAL); } x++; format_time(string_buffer, total_time, layout->columns[L_TOTAL_IDX].width); mvaddstr(y, x, string_buffer); } void free_memory() { reset_database(&database); reset_database(&archive); free(string_buffer); string_buffer = NULL; free(app_folder); app_folder = NULL; free(db_file_path); db_file_path = NULL; free(ar_file_path); ar_file_path = NULL; } bool initialize_app_folder() { char* home_path = getenv("HOME"); #if defined(_WIN64) home_path = getenv("USERPROFILE"); #endif if (home_path != NULL) { app_folder = malloc(strlen(home_path) + 1 + strlen(APP_FOLDER_NAME) + 1); // Add space for folder separator and NUL. // TODO Check malloc result. sprintf(app_folder, "%s/%s", home_path, APP_FOLDER_NAME); // Create app folder. mkdir(app_folder, 0740); if (errno != 0 && errno != EEXIST) { fprintf(stderr, "Failed to create app folder '%s': %s.\n", app_folder, strerror(errno)); return false; } } else { app_folder = malloc(3); // TODO Check malloc result. sprintf(app_folder, "./"); } // Set database file path. db_file_path = malloc(strlen(app_folder) + 1 + strlen(DB_FILE_NAME) + 1); // Add space for folder separator and NUL. // TODO Check malloc result. sprintf(db_file_path, "%s/%s", app_folder, DB_FILE_NAME); // Set archive file path. ar_file_path = malloc(strlen(app_folder) + 1 + strlen(AR_FILE_NAME) + 1); // Add space for folder separator and NUL. // TODO Check malloc result. sprintf(ar_file_path, "%s/%s", app_folder, AR_FILE_NAME); return true; } int main(int argc, char *argv[]) { if (initialize_app_folder() == false) { return EXIT_FAILURE; } db = &database; reset_database(&database); reset_database(&archive); if (is_file_accessible(db_file_path) == false) { store_database(&database, db_file_path); } if (is_file_accessible(ar_file_path) == false) { export_to_csv(&archive, ar_file_path); } if (argc > 1) { char *action; bool do_action = false; for (int idx = 1; idx < argc; idx++) { action = "--help"; do_action = strncmp(argv[idx], action, strlen(action)+1) == 0; if (do_action) { fprintf(stdout, "TO BE IMPLEMENTED\n"); // TODO return EXIT_SUCCESS; } action = "--version"; do_action = strncmp(argv[idx], action, strlen(action)+1) == 0; if (do_action) { fprintf(stdout, "Task Time Tracker " VERSION "\n"); free_memory(); return EXIT_SUCCESS; } action = "--icsv"; do_action = strncmp(argv[idx], action, strlen(action)+1) == 0; if (do_action) { if (idx+1 >= argc) { fprintf(stdout, "Missing CSV file path to import.\n"); return EXIT_FAILURE; } load_database(&database, db_file_path); import_from_csv(&database, argv[idx+1]); store_database(&database, db_file_path); free_memory(); return EXIT_SUCCESS; } action = "--ecsv"; do_action = strncmp(argv[idx], action, strlen(action)+1) == 0; if (do_action) { if (idx+1 >= argc) { fprintf(stdout, "Missing CSV file path to export.\n"); return EXIT_FAILURE; } load_database(&database, db_file_path); export_to_csv(&database, argv[idx+1]); free_memory(); return EXIT_SUCCESS; } } fprintf(stdout, "Unkown command '%s'.\nUse '%s --help' for list of commands.\n", argv[1], argv[0]); return EXIT_FAILURE; } initialize_tui(); load_database(&database, db_file_path); ungetch(KEY_RESIZE); for (int key; (key = getch()) != 'q'; ) { timeout(INPUT_AWAIT_INF); task_st *active_task = get_active_task(db); task_st *selected_task = get_selected_task(db); int selected_task_row = (db->selected_task % NUM_TABLE_ROWS) + NUM_HEADER_ROWS; int selected_task_theme = selected_task == active_task ? THEME_E : THEME_D; layout_st *layout; update_timers(&database); switch(key) { // When getch() times out. case ERR: { break; } // When terminal is resized. case KEY_RESIZE: { clear(); getmaxyx(stdscr, size_y, size_x); string_buffer = realloc(string_buffer, 511 | MAX_TASK_NAME | (size_x + 1)); // TODO This realloc sucks. recalculate_tui(); // TODO Maybe rename this function. layout = &layouts[size_x > 100 ? L_NORMAL : L_COMPACT]; break; } case 'n': case 'N':{ // Create new task. task_st *new_task; if (create_task(db, &new_task) == false) { // TODO ERROR break; } // Set new task name. time_t now_utc = time(NULL); struct tm *now_local = localtime(&now_utc); strftime(new_task->name, MAX_TASK_NAME, "%Y-%m-%d %H:%M:%S", now_local); // Select new task. selected_task = new_task; db->selected_task = selected_task - db->tasks; // Force rename action. ungetch(KEY_F(2)); break; } case KEY_F(2): { if (selected_task == NULL) { break; } // Prepare row to input new task name. attron(COLOR_PAIR(selected_task_theme) | A_BOLD | A_UNDERLINE); sprintf(string_buffer, "%*s", size_x - 2, ""); mvaddstr(selected_task_row, 1, string_buffer); // Get new task name. echo(); curs_set(1); mvgetnstr(selected_task_row, 1, string_buffer, MAX_TASK_NAME-1); noecho(); curs_set(0); // Apply new task name. if (is_empty_string(string_buffer) == false) { memcpy(selected_task->name, string_buffer, MAX_TASK_NAME); } attrset(A_NORMAL); break; } case KEY_DC: { // Delete if (selected_task == NULL || selected_task == active_task) { break; } attron(COLOR_PAIR(selected_task_theme) | A_BOLD); move(selected_task_row, 1); for (int idx = 0; idx < size_x - 2; idx++) { addch(ACS_CKBOARD); } mvaddstr(selected_task_row, 2, " Press enter to delete. "); attrset(A_NORMAL); if (getch() == '\n') { delete_task(db, selected_task); } break; } case 'm': case 'M': { if (selected_task == NULL) { break; } attron(COLOR_PAIR(selected_task_theme) | A_BOLD); move(selected_task_row, 1); addch(ACS_CKBOARD); addstr(" Move to: "); int input_pos_x = getcurx(stdscr); sprintf(string_buffer, "%*s", size_x - input_pos_x - 1, ""); attron(A_UNDERLINE); addstr(string_buffer); // Get line number. echo(); curs_set(1); mvgetnstr(selected_task_row, input_pos_x, string_buffer, MAX_TASK_NAME); // TODO use better value than MAX_TASK_NAME noecho(); curs_set(0); attrset(A_NORMAL); char *parser; intmax_t input = strtoimax(string_buffer, &parser, 10) - 1; if (parser == string_buffer) { break; } // TODO Implement move-task-to logic. size_t target = input < 0 ? 0 : input >= db->count ? db->count - 1 : input; move_task(db, selected_task, target); break; } case 'g': case 'G': { if (selected_task == NULL) { break; } attron(COLOR_PAIR(selected_task_theme) | A_BOLD); move(selected_task_row, 1); addch(ACS_CKBOARD); addstr(" Go to: "); int input_pos_x = getcurx(stdscr); sprintf(string_buffer, "%*s", size_x - input_pos_x - 1, ""); attron(A_UNDERLINE); addstr(string_buffer); // Get line number. echo(); curs_set(1); mvgetnstr(selected_task_row, input_pos_x, string_buffer, MAX_TASK_NAME); // TODO use better value than MAX_TASK_NAME noecho(); curs_set(0); attrset(A_NORMAL); char *parser; intmax_t input = strtoimax(string_buffer, &parser, 10) - 1; if (parser == string_buffer) { break; } db->selected_task = input < 0 ? 0 : input >= db->count ? db->count - 1 : input; break; } case 'd': case 'D':{ if (selected_task == NULL) { break; } add_task(db, selected_task); break; } case KEY_F(5): { update_total_timers(db); break; } case 'c': case 'C': { if (active_task != NULL) { db->selected_task = db->active_task; } break; } case '\n': case ' ': { if (db != &database) { break; } task_st *next_task = selected_task; if (active_task != NULL) { update_timers(db); // TODO Should I keep this even though it always does? db->active_task = -1; } if (active_task != next_task) { db->active_task = next_task - db->tasks; } db->modified_on = time(NULL); store_database(db, db_file_path); break; } case '\t': { if (db == &database) { reset_database(&archive); // TODO Not needed because we never leave things hanging. import_from_csv(&archive, ar_file_path); db = &archive; } else { export_to_csv(&archive, ar_file_path); reset_database(&archive); db = &database; } break; } case 'a': case 'A': { if (db != &database || selected_task == NULL || selected_task == active_task) { break; } append_to_csv(selected_task, ar_file_path); delete_task(db, selected_task); // TODO Maybe save stuff? Shoulw we? break; } case 'u': case 'U': { if (db != &archive || selected_task == NULL) { break; } add_task(&database, selected_task); delete_task(db, selected_task); // TODO Maybe save stuff? Shoulw we? break; } case KEY_LEFT: break; case KEY_RIGHT: break; case KEY_HOME: { if (db->count > 0) { db->selected_task = 0; } break; } case KEY_UP: { if (db->selected_task > 0) { db->selected_task--; } break; } case KEY_PPAGE: { if (db->selected_task > NUM_TABLE_ROWS) { db->selected_task -= NUM_TABLE_ROWS; } else if (db->count > 0) { db->selected_task = 0; } break; } case KEY_END: { if (db->count > 0) { db->selected_task = db->count - 1; } break; } case KEY_DOWN: { if (db->selected_task < db->count - 1) { db->selected_task++; } break; } case KEY_NPAGE: { if (db->selected_task < db->count - NUM_TABLE_ROWS) { db->selected_task += NUM_TABLE_ROWS; } else if (db->count > 0) { db->selected_task = db->count - 1; } break; } } if (size_x >= 60 && size_y >= 3) { draw_tui(db, layout); } else { const char *INVALID_WINDOW_MESSAGE = "Please expand window."; mvaddstr(size_y / 2, (size_x - strlen(INVALID_WINDOW_MESSAGE)) / 2, INVALID_WINDOW_MESSAGE); } timeout(INPUT_TIMEOUT_MS); } update_timers(&database); store_database(&database, db_file_path); if (db == &archive) { export_to_csv(&archive, ar_file_path); } free_memory(); endwin(); return EXIT_SUCCESS; }