X-Git-Url: http://git.wpitchoune.net/gitweb/?a=blobdiff_plain;f=src%2Fmain.c;h=36c0d19872b304309c81a0d18ca6a3c9489eedfc;hb=3a4f20601cd297f4e7db412e377a0f649363e136;hp=62fa99c35054131005d0411d1c8e6377436d543c;hpb=150347d61ee08df85b377c5af0c5c2d7b3cc8716;p=ptask.git diff --git a/src/main.c b/src/main.c index 62fa99c..36c0d19 100644 --- a/src/main.c +++ b/src/main.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 2010-2012 jeanfi@gmail.com + * Copyright (C) 2012-2013 jeanfi@gmail.com * * This program is free software; you can redistribute it and/or * modify it under the terms of the GNU General Public License as @@ -19,315 +19,535 @@ #include #include #include +#include +#include #include +#include #include -struct task { - int id; - char *description; - char *status; - char *uuid; - char *note; - char *project; -}; +#include + +#include "log.h" +#include "note.h" +#include "tw.h" +static const char *program_name; static struct task **tasks; static GtkTextView *w_note; static GtkEntry *w_description; +static GtkEntry *w_project; static GtkTreeView *w_treeview; +static GtkWidget *w_tasksave_btn; +static GtkWidget *w_taskdone_btn; +static GtkComboBox *w_status; +static GtkComboBox *w_priority; + +enum { + COL_ID, + COL_DESCRIPTION, + COL_PROJECT, + COL_UUID, + COL_PRIORITY +}; + +static struct option long_options[] = { + {"version", no_argument, 0, 'v'}, + {"help", no_argument, 0, 'h'}, + {"debug", required_argument, 0, 'd'}, + {0, 0, 0, 0} +}; -static char *task_exec(char *opts) +static void print_version() { - FILE *f; - int ret, s; - char *str, *tmp, *cmd, buf[1024]; + printf("ptask %s\n", VERSION); + printf(_("Copyright (C) %s jeanfi@gmail.com\n" + "License GPLv2: GNU GPL version 2 or later " + "\n" + "This is free software: you are free to change and " + " redistribute it.\n" + "There is NO WARRANTY, to the extent permitted by law.\n"), + "2012-2013"); +} - str = NULL; +static void print_help() +{ + printf(_("Usage: %s [OPTION]...\n"), program_name); - cmd = malloc(strlen("task rc.json.array=on ") + strlen(opts) + 1); - strcpy(cmd, "task rc.json.array=on "); - strcat(cmd, opts); + puts(_("ptask is a task management user interface based" + " on taskwarrior.")); - printf("execute: %s\n", cmd); + puts(""); + puts(_("Options:")); + puts(_(" -h, --help display this help and exit\n" + " -v, --version display version information and exit")); - f = popen(cmd, "r"); + puts(""); - if (!f) { - perror("popen"); - goto exit_free; - } + puts(_(" -d, --debug=LEVEL " + "set the debug level, integer between 0 and 3")); - str = malloc(1); - str[0] = '\0'; - while ((s = fread(buf, 1, 1024, f))) { - tmp = malloc(strlen(str) + s + 1); - memcpy(tmp, str, strlen(str)); - memcpy(tmp + strlen(str), buf, s); - tmp[strlen(str) + s] = '\0'; - free(str); - str = tmp; - } + puts(""); - ret = pclose(f); + printf(_("Report bugs to: %s\n"), PACKAGE_BUGREPORT); + puts(""); + printf(_("%s home page: <%s>\n"), PACKAGE_NAME, PACKAGE_URL); +} - if (ret == -1) { - printf("pclose fails\n"); - perror("pclose"); - } +static struct task *get_selected_task(GtkTreeView *treeview) +{ + GtkTreePath *path; + GtkTreeViewColumn *cols; + struct task **tasks_cur; + GtkTreeIter iter; + GtkTreeModel *model; + GValue value = {0,}; + const char *uuid; - exit_free: - free(cmd); + log_debug("get_selected_task"); - return str; -} + gtk_tree_view_get_cursor(treeview, &path, &cols); -static struct json_object *task_exec_json(char *opts) -{ - struct json_object *o; - char *str; + if (path) { + model = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview)); + gtk_tree_model_get_iter(model, &iter, path); + gtk_tree_model_get_value(model, &iter, COL_UUID, &value); + + uuid = g_value_get_string(&value); - str = task_exec(opts); + for (tasks_cur = tasks; *tasks_cur; tasks_cur++) + if (!strcmp((*tasks_cur)->uuid, uuid)) + return *tasks_cur; - if (str) { - o = json_tokener_parse(str); - free(str); - return o; + gtk_tree_path_free(path); } return NULL; } -static struct task **get_all_tasks() +static void clear_task_panel() { - int i, n; - struct json_object *jtasks, *jtask, *json; - struct task **tasks; - - jtasks = task_exec_json("export"); + GtkTextBuffer *buf; - if (!jtasks) - return NULL; + gtk_widget_set_sensitive(w_tasksave_btn, 0); + gtk_widget_set_sensitive(w_taskdone_btn, 0); - n = json_object_array_length(jtasks); + buf = gtk_text_view_get_buffer(w_note); + gtk_text_buffer_set_text(buf, "", 0); + gtk_widget_set_sensitive(GTK_WIDGET(w_note), 0); - tasks = malloc((n + 1) * sizeof(struct task *)); + gtk_entry_set_text(w_description, ""); + gtk_widget_set_sensitive(GTK_WIDGET(w_description), 0); - for (i = 0; i < n; i++) { - jtask = json_object_array_get_idx(jtasks, i); + gtk_entry_set_text(w_project, ""); + gtk_widget_set_sensitive(GTK_WIDGET(w_project), 0); - tasks[i] = malloc(sizeof(struct task)); + gtk_combo_box_set_active(w_priority, 0); + gtk_widget_set_sensitive(GTK_WIDGET(w_priority), 0); +} - json = json_object_object_get(jtask, "id"); - tasks[i]->id = json_object_get_int(json); +static void refresh() +{ + GtkWidget *dialog; + GtkTreeModel *model; + struct task **tasks_cur; + struct task *task; + int i; + GtkTreeIter iter; + int status; + const char *project; + + log_debug("refresh"); + clear_task_panel(); + + status = gtk_combo_box_get_active(w_status); + log_debug("status: %d", status); + + if (tasks) + tw_task_list_free(tasks); + + switch (status) { + case 0: + tasks = tw_get_all_tasks("pending"); + break; + case 1: + tasks = tw_get_all_tasks("completed"); + break; + default: + tasks = tw_get_all_tasks("pending"); + } - json = json_object_object_get(jtask, "description"); - tasks[i]->description = strdup(json_object_get_string(json)); + model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview)); + gtk_list_store_clear(GTK_LIST_STORE(model)); - json = json_object_object_get(jtask, "status"); - tasks[i]->status = strdup(json_object_get_string(json)); + if (tasks) { + for (tasks_cur = tasks, i = 0; *tasks_cur; tasks_cur++, i++) { + task = (*tasks_cur); - json = json_object_object_get(jtask, "project"); - if (json) - tasks[i]->project - = strdup(json_object_get_string(json)); - else - tasks[i]->project = NULL; + gtk_list_store_append(GTK_LIST_STORE(model), &iter); - json = json_object_object_get(jtask, "uuid"); - tasks[i]->uuid = strdup(json_object_get_string(json)); + if (task->project) + project = task->project; + else + project = ""; - tasks[i]->note = NULL; + gtk_list_store_set(GTK_LIST_STORE(model), + &iter, + COL_ID, (*tasks_cur)->id, + COL_DESCRIPTION, + (*tasks_cur)->description, + COL_PROJECT, project, + COL_UUID, (*tasks_cur)->uuid, + COL_PRIORITY, (*tasks_cur)->priority, + -1); + } + } else { + dialog = gtk_message_dialog_new(NULL, + GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_MESSAGE_ERROR, + GTK_BUTTONS_CLOSE, + _("Error loading tasks, verify " + "that a supported version of " + "taskwarrior is installed ")); + gtk_dialog_run(GTK_DIALOG(dialog)); + gtk_widget_destroy(dialog); } + log_debug("refresh done"); +} - tasks[n] = NULL; +int taskdone_clicked_cbk(GtkButton *btn, gpointer data) +{ + struct task *task; - json_object_put(jtasks); + task = get_selected_task(GTK_TREE_VIEW(w_treeview)); + tw_done(task->uuid); + refresh(); - return tasks; + return FALSE; } -static struct task *get_selected_task(GtkTreeView *treeview) +static int tasksave_clicked_cbk(GtkButton *btn, gpointer data) { - GtkTreePath *path; - GtkTreeViewColumn *cols; - gint *i; struct task *task; + GtkTextBuffer *buf; + char *txt, *pri; + GtkTextIter sIter, eIter; + const char *ctxt; + int priority; - gtk_tree_view_get_cursor(treeview, &path, &cols); + task = get_selected_task(GTK_TREE_VIEW(w_treeview)); - if (path) { - i = gtk_tree_path_get_indices(path); - - if (i) - printf("row selected: %d\n", *i); + log_debug("tasksave_clicked_cbk %d", task->id); - task = tasks[*i]; + buf = gtk_text_view_get_buffer(w_note); - gtk_tree_path_free(path); + gtk_text_buffer_get_iter_at_offset(buf, &sIter, 0); + gtk_text_buffer_get_iter_at_offset(buf, &eIter, -1); + txt = gtk_text_buffer_get_text(buf, &sIter, &eIter, TRUE); + + log_debug("note=%s", txt); - return task; + if (!task->note || strcmp(txt, task->note)) + note_put(task->uuid, txt); + + ctxt = gtk_entry_get_text(w_description); + if (!task->description || strcmp(ctxt, task->description)) + tw_modify_description(task->uuid, ctxt); + + ctxt = gtk_entry_get_text(w_project); + if (!task->project || strcmp(ctxt, task->project)) + tw_modify_project(task->uuid, ctxt); + + priority = gtk_combo_box_get_active(w_priority); + log_debug("priority: %d", priority); + + switch (priority) { + case 3: + pri = "H"; + break; + case 2: + pri = "M"; + break; + case 1: + pri = "L"; + break; + default: + pri = ""; } - return NULL; + if (strcmp(task->priority, pri)) + tw_modify_priority(task->uuid, pri); + + refresh(); + + return FALSE; } -static char *escape(const char *txt) +int refresh_clicked_cbk(GtkButton *btn, gpointer data) { - char *result; - char *c; + log_debug("refresh_clicked_cbk"); + refresh(); - result = malloc(2*strlen(txt)+1); - c = result; - - while(*txt) { - switch(*txt) { - case '"': - *c = '\\'; c++; - *c = '"'; - break; - case '$': - *c = '\\'; c++; - *c = '$'; - break; - case '&': - *c = '\\'; c++; - *c = '&'; - break; - default: - *c = *txt; - } - c++; - txt++; - } + return FALSE; +} - *c = '\0'; +static gboolean delete_event_cbk(GtkWidget *w, GdkEvent *evt, gpointer data) +{ + gtk_widget_destroy(w); + gtk_main_quit(); - return result; + return FALSE; } -static int tasksave_clicked_cbk(GtkButton *btn, gpointer data) + +int newtask_clicked_cbk(GtkButton *btn, gpointer data) { - struct task *task; - GtkTextBuffer *buf; - char *txt, *opts; - GtkTextIter sIter, eIter; + gint result; + static GtkDialog *diag; + GtkBuilder *builder; + GtkEntry *entry; const char *ctxt; - task = get_selected_task(GTK_TREE_VIEW(w_treeview)); + log_debug("newtask_clicked_cbk"); - printf("tasksave_clicked_cbk %d\n", task->id); + builder = gtk_builder_new(); + gtk_builder_add_from_file + (builder, + PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "ptask.glade", + NULL); + diag = GTK_DIALOG(gtk_builder_get_object(builder, "diag_tasknew")); + gtk_builder_connect_signals(builder, NULL); - if (task->note) { - buf = gtk_text_view_get_buffer(w_note); + result = gtk_dialog_run(diag); - gtk_text_buffer_get_iter_at_offset(buf, &sIter, 0); - gtk_text_buffer_get_iter_at_offset(buf, &eIter, -1); - txt = gtk_text_buffer_get_text(buf, &sIter, &eIter, TRUE); + if (result == GTK_RESPONSE_ACCEPT) { + log_debug("ok"); + entry = GTK_ENTRY(gtk_builder_get_object + (builder, "diag_tasknew_description")); + ctxt = gtk_entry_get_text(entry); - txt = escape(txt); + log_debug("%s", ctxt); - printf("%s\n", txt); + tw_add(ctxt); + refresh(); + } else { + log_debug("cancel"); } - ctxt = gtk_entry_get_text(w_description); - txt = escape(ctxt); - - opts = malloc(1 - + strlen(task->uuid) - + strlen(" modify description:\"") - + strlen(txt) - + strlen("\"") - + 1); - sprintf(opts, " %s modify \"%s\"", task->uuid, txt); - - task_exec(opts); - - free(txt); - + g_object_unref(G_OBJECT(builder)); + + gtk_widget_destroy(GTK_WIDGET(diag)); + return FALSE; } +static int status_changed_cbk(GtkComboBox *w, gpointer data) +{ + log_debug("status_changed_cbk"); + refresh(); + + return FALSE; +} + +static int priority_to_int(const char *str) +{ + switch (*str) { + case 'H': + return 3; + case 'M': + return 2; + case 'L': + return 1; + default: + return 0; + } +} + static int cursor_changed_cbk(GtkTreeView *treeview, gpointer data) { struct task *task; GtkTextBuffer *buf; + int priority; - printf("cursor_changed_cbk\n"); + log_debug("cursor_changed_cbk"); task = get_selected_task(treeview); if (task) { - if (task->note) { - buf = gtk_text_view_get_buffer(w_note); + buf = gtk_text_view_get_buffer(w_note); + if (task->note) gtk_text_buffer_set_text(buf, task->note, strlen(task->note)); - } + else + gtk_text_buffer_set_text(buf, "", 0); + gtk_widget_set_sensitive(GTK_WIDGET(w_note), 1); gtk_entry_set_text(w_description, task->description); + gtk_widget_set_sensitive(GTK_WIDGET(w_description), 1); + + if (task->project) + gtk_entry_set_text(w_project, task->project); + else + gtk_entry_set_text(w_project, ""); + gtk_widget_set_sensitive(GTK_WIDGET(w_project), 1); + + gtk_widget_set_sensitive(w_tasksave_btn, 1); + gtk_widget_set_sensitive(w_taskdone_btn, 1); + + gtk_widget_set_sensitive(GTK_WIDGET(w_priority), 1); + priority = priority_to_int(task->priority); + gtk_combo_box_set_active(w_priority, priority); + } else { + log_debug("clear task widgets"); + clear_task_panel(); + log_debug("clear task widgets done"); } return FALSE; } +static gint priority_cmp(GtkTreeModel *model, + GtkTreeIter *a, + GtkTreeIter *b, + gpointer user_data) +{ + GValue v1 = {0,}, v2 = {0,}; + const char *str1, *str2; + int i1, i2; + + gtk_tree_model_get_value(model, a, COL_PRIORITY, &v1); + str1 = g_value_get_string(&v1); + i1 = priority_to_int(str1); + + gtk_tree_model_get_value(model, b, COL_PRIORITY, &v2); + str2 = g_value_get_string(&v2); + i2 = priority_to_int(str2); + + if (i1 < i2) + return -1; + else if (i1 > i2) + return 1; + else + return 0; +} + +static void log_init() +{ + char *home, *path, *dir; + + home = getenv("HOME"); + + if (!home) + return ; + + dir = malloc(strlen(home)+1+strlen(".ptask")+1); + sprintf(dir, "%s/%s", home, ".ptask"); + mkdir(dir, 0777); + + path = malloc(strlen(dir)+1+strlen("log")+1); + sprintf(path, "%s/%s", dir, "log"); + + log_open(path); + + free(dir); + free(path); +} + int main(int argc, char **argv) { - GtkWidget *window; - GtkWidget *btn; + GtkWidget *window, *btn; GtkBuilder *builder; - GtkTreeIter iter; - int i; GtkTreeModel *model; - struct task **tasks_cur; - struct task *task; + int optc, cmdok, opti; + + program_name = argv[0]; + + setlocale(LC_ALL, ""); + +#if ENABLE_NLS + bindtextdomain(PACKAGE, LOCALEDIR); + textdomain(PACKAGE); +#endif + + cmdok = 1; + while ((optc = getopt_long(argc, argv, "vhd:", long_options, + &opti)) != -1) { + switch (optc) { + case 'h': + print_help(); + exit(EXIT_SUCCESS); + case 'v': + print_version(); + exit(EXIT_SUCCESS); + case 'd': + log_level = atoi(optarg); + log_info(_("Enables debug mode.")); + break; + default: + cmdok = 0; + break; + } + } + + if (!cmdok || optind != argc) { + fprintf(stderr, _("Try `%s --help' for more information.\n"), + program_name); + exit(EXIT_FAILURE); + } + + log_init(); gtk_init(NULL, NULL); builder = gtk_builder_new(); gtk_builder_add_from_file (builder, - PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "gtask.glade", + PACKAGE_DATA_DIR G_DIR_SEPARATOR_S "ptask.glade", NULL); window = GTK_WIDGET(gtk_builder_get_object(builder, "window")); - printf("%p\n", window); + + g_signal_connect(window, "delete_event", + G_CALLBACK(delete_event_cbk), NULL); w_treeview = GTK_TREE_VIEW(gtk_builder_get_object(builder, "treeview")); + model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview)); + gtk_tree_sortable_set_sort_func(GTK_TREE_SORTABLE(model), + COL_PRIORITY, + priority_cmp, + NULL, + NULL); w_note = GTK_TEXT_VIEW(gtk_builder_get_object(builder, "tasknote")); w_description = GTK_ENTRY(gtk_builder_get_object(builder, "taskdescription")); + w_project = GTK_ENTRY(gtk_builder_get_object(builder, "taskproject")); + w_status = GTK_COMBO_BOX(gtk_builder_get_object(builder, "status")); + w_priority = GTK_COMBO_BOX(gtk_builder_get_object(builder, + "taskpriority")); - model = gtk_tree_view_get_model(GTK_TREE_VIEW(w_treeview)); - - tasks = get_all_tasks(); + refresh(); - for (tasks_cur = tasks, i = 0; *tasks_cur; tasks_cur++, i++) { - task = (*tasks_cur); - - gtk_list_store_append(GTK_LIST_STORE(model), &iter); - - if (task->project) - gtk_list_store_set(GTK_LIST_STORE(model), - &iter, - 2, task->project, - -1); - - gtk_list_store_set(GTK_LIST_STORE(model), - &iter, - 0, (*tasks_cur)->id, - 1, (*tasks_cur)->description, - -1); - } + gtk_builder_connect_signals(builder, NULL); g_signal_connect(w_treeview, - "cursor-changed", (GCallback)cursor_changed_cbk, tasks); + "cursor-changed", (GCallback)cursor_changed_cbk, + tasks); + g_signal_connect(w_status, + "changed", (GCallback)status_changed_cbk, + tasks); btn = GTK_WIDGET(gtk_builder_get_object(builder, "tasksave")); g_signal_connect(btn, "clicked", (GCallback)tasksave_clicked_cbk, tasks); + gtk_widget_set_sensitive(btn, 0); + w_tasksave_btn = btn; + + w_taskdone_btn = GTK_WIDGET(gtk_builder_get_object(builder, + "taskdone")); + gtk_widget_set_sensitive(w_taskdone_btn, 0); g_object_unref(G_OBJECT(builder));